@netlify/zip-it-and-ship-it 14.5.6 → 14.7.0

package/dist/config.d.ts

@@ -1,6 +1,8 @@
+import type { FunctionRegion } from '@netlify/types';
 import { z } from 'zod';
 import { FunctionSource } from './function.js';
-export declare const functionConfig: z.ZodObject<{
+export declare const functionConfigShape: 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">>>;
@@ -16,9 +18,12 @@ export declare const functionConfig: 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";
@@ -26,6 +31,7 @@ export declare const functionConfig: z.ZodObject<{
     }>>>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
+    background?: boolean | undefined;
     externalNodeModules?: string[] | undefined;
     generator?: string | undefined;
     includedFiles?: string[] | undefined;
@@ -34,13 +40,17 @@ export declare const functionConfig: z.ZodObject<{
     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;
@@ -49,13 +59,121 @@ export declare const functionConfig: z.ZodObject<{
     nodeBundler?: unknown;
     nodeSourcemap?: unknown;
     nodeVersion?: unknown;
+    memory?: unknown;
+    region?: unknown;
     rustTargetDirectory?: unknown;
     schedule?: unknown;
     timeout?: unknown;
+    vcpu?: number | undefined;
     zipGo?: unknown;
     nodeModuleFormat?: unknown;
 }>;
-type FunctionConfig = z.infer<typeof functionConfig>;
+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<{
+        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;
+}>;
+type FunctionConfig = z.infer<typeof functionConfigShape>;
 type GlobPattern = string;
 type Config = Record<GlobPattern, FunctionConfig>;
 type FunctionWithoutConfig = Omit<FunctionSource, 'config'>;

package/dist/config.js

@@ -8,7 +8,43 @@ import { z } from 'zod';
 import { nodeBundler } from './runtimes/node/bundlers/types.js';
 import { moduleFormat } from './runtimes/node/utils/module_format.js';
 import { minimatch } from './utils/matching.js';
-export const functionConfig = z.object({
+import { parseMemoryMB } from './utils/parse_memory.js';
+// We only need the list of valid region codes here (to feed into Zod's
+// `enum` for runtime validation). The natural shape would be a literal
+// array, but TypeScript has no way to enforce that an array contains every
+// member of a union type — it can only check that each element belongs to
+// the union, not that none are missing.
+//
+// A Record keyed by the union, however, IS exhaustiveness-checked: with
+// `satisfies Record<FunctionRegion, ...>`, TypeScript refuses to compile
+// if any region in `FunctionRegion` is absent here, or if anything here
+// isn't a valid `FunctionRegion`.
+const FUNCTION_REGION_KEYS = {
+    cmh: null,
+    dub: null,
+    fra: null,
+    gru: null,
+    iad: null,
+    lhr: null,
+    nrt: null,
+    pdx: null,
+    sfo: null,
+    sin: null,
+    syd: null,
+    yul: null,
+};
+const FUNCTION_REGION_CODES = Object.keys(FUNCTION_REGION_KEYS);
+// Accept any casing in source (`iad`, `IAD`, `Iad`) but normalize to lower
+// case before validating and writing to the manifest.
+const functionRegion = z.preprocess((input) => (typeof input === 'string' ? input.toLowerCase() : input), z.enum(FUNCTION_REGION_CODES));
+const FUNCTION_MEMORY_MIN_MB = 1024;
+const FUNCTION_MEMORY_MAX_MB = 4096;
+const functionMemory = z.preprocess((input) => (typeof input === 'string' || typeof input === 'number' ? parseMemoryMB(input) : input), z.number().int().min(FUNCTION_MEMORY_MIN_MB).max(FUNCTION_MEMORY_MAX_MB));
+const FUNCTION_VCPU_MIN = 0.5;
+const FUNCTION_VCPU_MAX = 2;
+const functionVcpu = z.number().min(FUNCTION_VCPU_MIN).max(FUNCTION_VCPU_MAX);
+export const functionConfigShape = z.object({
+    background: z.boolean().optional().catch(undefined),
     externalNodeModules: z.array(z.string()).optional().catch([]),
     generator: z.string().optional().catch(undefined),
     includedFiles: z.array(z.string()).optional().catch([]),
@@ -18,15 +54,23 @@ export const functionConfig = z.object({
     nodeBundler: nodeBundler.optional().catch(undefined),
     nodeSourcemap: z.boolean().optional().catch(undefined),
     nodeVersion: z.string().optional().catch(undefined),
+    memory: functionMemory.optional(),
+    region: functionRegion.optional(),
     rustTargetDirectory: z.string().optional().catch(undefined),
     schedule: z.string().optional().catch(undefined),
     timeout: z.number().optional().catch(undefined),
+    vcpu: functionVcpu.optional(),
     zipGo: z.boolean().optional().catch(undefined),
     // Temporary configuration property, only meant to be used by the deploy
     // configuration API. Once we start emitting ESM files for all ESM functions,
     // 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/manifest.d.ts

@@ -11,15 +11,18 @@ interface ManifestFunction {
     generator?: string;
     invocationMode?: InvocationMode;
     mainFile: string;
+    memory?: number;
     name: string;
     path: string;
     priority?: number;
+    region?: string;
     routes?: ExtendedRoute[];
     runtime: string;
     runtimeVersion?: string;
     schedule?: string;
     timeout?: number;
     trafficRules?: TrafficRules;
+    vcpu?: number;
 }
 export interface Manifest {
     functions: ManifestFunction[];

package/dist/manifest.js

@@ -12,7 +12,7 @@ export const createManifest = async ({ functions, path }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatFunctionForManifest = ({ bootstrapVersion, bundler, displayName, eventSubscriptions, excludedRoutes, generator, invocationMode, mainFile, name, path, priority, trafficRules, routes, runtime, runtimeVersion, runtimeAPIVersion, schedule, timeout, }) => {
+const formatFunctionForManifest = ({ bootstrapVersion, bundler, displayName, eventSubscriptions, excludedRoutes, generator, invocationMode, mainFile, memory, name, path, priority, region, trafficRules, routes, runtime, runtimeVersion, runtimeAPIVersion, schedule, timeout, vcpu, }) => {
     const manifestFunction = {
         bundler,
         displayName,
@@ -21,13 +21,16 @@ const formatFunctionForManifest = ({ bootstrapVersion, bundler, displayName, eve
         invocationMode,
         buildData: { bootstrapVersion, runtimeAPIVersion },
         mainFile,
+        memory,
         name,
         priority,
+        region,
         trafficRules,
         runtimeVersion,
         path: resolve(path),
         runtime,
         schedule,
+        vcpu,
     };
     if (eventSubscriptions?.length) {
         manifestFunction.eventSubscriptions = eventSubscriptions;

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

@@ -21,7 +21,8 @@ declare const httpMethod: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "OPTIONS", "
 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.ZodObject<Pick<{
+export declare const inSourceConfig: z.ZodEffects<z.ZodObject<Pick<{
+    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">>>;
@@ -37,15 +38,18 @@ export declare const inSourceConfig: z.ZodObject<Pick<{
     }>>>;
     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>>;
     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" | "externalNodeModules" | "generator" | "includedFiles" | "ignoredNodeModules" | "nodeBundler" | "nodeVersion" | "schedule" | "timeout"> & {
+}, "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[]>>;
@@ -77,14 +81,18 @@ export declare const inSourceConfig: z.ZodObject<Pick<{
 }, "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;
@@ -99,14 +107,63 @@ export declare const inSourceConfig: z.ZodObject<Pick<{
 }, {
     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;
@@ -126,6 +183,7 @@ 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;
@@ -134,22 +192,29 @@ export declare const augmentFunctionConfig: (mainFile: string, tomlConfig: Funct
     nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
     nodeSourcemap?: boolean | undefined;
     nodeVersion?: string | undefined;
+    memory?: number | undefined;
+    region?: import("@netlify/types").FunctionRegion | undefined;
     rustTargetDirectory?: string | undefined;
     schedule?: string | undefined;
     timeout?: number | undefined;
+    vcpu?: number | undefined;
     zipGo?: boolean | undefined;
     nodeModuleFormat?: "cjs" | "esm" | undefined;
 } & {
     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;

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

@@ -3,7 +3,7 @@ import { dirname } from 'path';
 // this dependency.
 import mergeOptions from 'merge-options';
 import { z } from 'zod';
-import { functionConfig } from '../../../config.js';
+import { functionConfigShape } from '../../../config.js';
 import { INVOCATION_MODE } from '../../../function.js';
 import { rateLimit } from '../../../rate_limit.js';
 import { ensureArray } from '../../../utils/ensure_array.js';
@@ -11,7 +11,7 @@ import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { getRoutes } from '../../../utils/routes.js';
 import { RUNTIME } from '../../runtime.js';
 import { createBindingsMethod } from '../parser/bindings.js';
-import { traverseNodes } from '../parser/exports.js';
+import { parseObject, traverseNodes } from '../parser/exports.js';
 import { getImports } from '../parser/imports.js';
 import { safelyParseSource, safelyReadSource } from '../parser/index.js';
 import { eventHandlers } from '@netlify/serverless-functions-api';
@@ -20,17 +20,21 @@ export const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
 const httpMethod = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE', 'HEAD']);
 const httpMethods = z.preprocess((input) => (typeof input === 'string' ? input.toUpperCase() : input), httpMethod);
 const path = z.string().startsWith('/', { message: "Must start with a '/'" });
-export const inSourceConfig = functionConfig
+export const inSourceConfig = functionConfigShape
     .pick({
+    background: true,
     externalNodeModules: true,
     generator: true,
     includedFiles: true,
     ignoredNodeModules: true,
+    memory: true,
     name: true,
     nodeBundler: true,
     nodeVersion: true,
+    region: true,
     schedule: true,
     timeout: true,
+    vcpu: true,
 })
     .extend({
     method: z
@@ -49,22 +53,45 @@ export const inSourceConfig = functionConfig
         .optional(),
     preferStatic: z.boolean().optional().catch(undefined),
     rateLimit: rateLimit.optional().catch(undefined),
+})
+    .refine((cfg) => !(cfg.memory !== undefined && cfg.vcpu !== undefined), {
+    message: '`memory` and `vcpu` cannot both be set.',
+    path: ['vcpu'],
 });
 /**
- * Extracts event subscription slugs from the default export expression,
- * if it's an object whose property names match known event handlers.
+ * Resolves the default export expression to an ObjectExpression if possible,
+ * following identifier bindings when needed.
  */
-const getEventSubscriptions = (expression, getAllBindings) => {
-    let objectExpression;
-    if (expression?.type === 'ObjectExpression') {
-        objectExpression = expression;
+const resolveObjectExpression = (expression, getAllBindings) => {
+    // Unwrap TS type assertions so `{...} satisfies T` and `{...} as T` are
+    // treated the same as the bare object literal.
+    const unwrapped = expression?.type === 'TSSatisfiesExpression' ||
+        expression?.type === 'TSAsExpression' ||
+        expression?.type === 'TSTypeAssertion'
+        ? expression.expression
+        : expression;
+    if (unwrapped?.type === 'ObjectExpression') {
+        return unwrapped;
     }
-    else if (expression?.type === 'Identifier') {
-        const binding = getAllBindings().get(expression.name);
+    if (unwrapped?.type === 'Identifier') {
+        let binding = getAllBindings().get(unwrapped.name);
+        if (binding?.type === 'TSSatisfiesExpression' ||
+            binding?.type === 'TSAsExpression' ||
+            binding?.type === 'TSTypeAssertion') {
+            binding = binding.expression;
+        }
         if (binding?.type === 'ObjectExpression') {
-            objectExpression = binding;
+            return binding;
         }
     }
+    return undefined;
+};
+/**
+ * Extracts event subscription slugs from the default export expression,
+ * if it's an object whose property names match known event handlers.
+ */
+const getEventSubscriptions = (expression, getAllBindings) => {
+    const objectExpression = resolveObjectExpression(expression, getAllBindings);
     if (!objectExpression) {
         return [];
     }
@@ -81,6 +108,34 @@ const getEventSubscriptions = (expression, getAllBindings) => {
     }
     return events;
 };
+/**
+ * Extracts a `config` property from the default export object expression,
+ * returning it as a plain object. This supports patterns like:
+ *
+ * ```js
+ * export default {
+ *   fetch() { ... },
+ *   config: { path: "/hello" }
+ * }
+ * ```
+ */
+const getConfigFromDefaultExport = (expression, getAllBindings) => {
+    const objectExpression = resolveObjectExpression(expression, getAllBindings);
+    if (!objectExpression) {
+        return undefined;
+    }
+    for (const property of objectExpression.properties) {
+        if (property.type !== 'ObjectProperty' || property.value.type !== 'ObjectExpression') {
+            continue;
+        }
+        const isConfigKey = (property.key.type === 'Identifier' && property.key.name === 'config') ||
+            (property.key.type === 'StringLiteral' && property.key.value === 'config');
+        if (isConfigKey) {
+            return parseObject(property.value);
+        }
+    }
+    return undefined;
+};
 const validateScheduleFunction = (functionFound, scheduleFound, functionName) => {
     if (!functionFound) {
         throw new FunctionBundlingUserError("The `schedule` helper was imported but we couldn't find any usages. If you meant to schedule a function, please check that `schedule` is invoked and `handler` correctly exported.", { functionName, runtime: RUNTIME.JAVASCRIPT });
@@ -131,7 +186,12 @@ export const parseSource = (source, { functionName }) => {
         if (eventSubscriptions.length > 0) {
             result.eventSubscriptions = eventSubscriptions;
         }
-        const { data, error, success } = inSourceConfig.safeParse(configExport);
+        // A named `export const config` always wins (even if empty); we fall back
+        // to the `config` property of the default export object only when no
+        // named export exists.
+        const inlineConfig = getConfigFromDefaultExport(defaultExportExpression, getAllBindings);
+        const mergedConfigExport = configExport ?? inlineConfig ?? {};
+        const { data, error, success } = inSourceConfig.safeParse(mergedConfigExport);
         if (success) {
             result.config = data;
             result.excludedRoutes = getRoutes(functionName, data.excludedPath);
@@ -140,6 +200,9 @@ export const parseSource = (source, { functionName }) => {
                 methods: data.method ?? [],
                 prefer_static: data.preferStatic || undefined,
             }));
+            if (data.background) {
+                result.invocationMode = INVOCATION_MODE.Background;
+            }
         }
         else {
             // TODO: Handle multiple errors.

package/dist/runtimes/node/index.js

@@ -104,16 +104,25 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     });
     await cleanupFunction?.();
     // Getting the invocation mode from ISC, in case the function is using the
-    // `stream` helper.
+    // `stream` helper or set `background: true` in the in-source config.
     let { invocationMode } = staticAnalysisResult;
-    // If we're using the V2 API, force the invocation to "stream".
-    if (runtimeAPIVersion === 2) {
-        invocationMode = INVOCATION_MODE.Stream;
-    }
-    // If this is a background function, set the right `invocationMode` value.
+    // If this is a background function (filename suffix), set the right
+    // `invocationMode` value.
     if (name.endsWith('-background')) {
         invocationMode = INVOCATION_MODE.Background;
     }
+    // `background: true` in the merged config (e.g. via `[functions.<name>]` in
+    // `netlify.toml`) also marks the function as background. The in-source
+    // config has already been folded into `mergedConfig` by this point, so this
+    // check covers both TOML-only and in-source declarations.
+    if (mergedConfig?.background === true) {
+        invocationMode = INVOCATION_MODE.Background;
+    }
+    // V2 functions default to streamed invocation unless they were already
+    // marked as background (via filename suffix or `config.background: true`).
+    if (runtimeAPIVersion === 2 && invocationMode !== INVOCATION_MODE.Background) {
+        invocationMode = INVOCATION_MODE.Stream;
+    }
     const outputModuleFormat = extname(finalMainFile) === MODULE_FILE_EXTENSION.MJS ? MODULE_FORMAT.ESM : MODULE_FORMAT.COMMONJS;
     const priority = isInternal ? Priority.GeneratedFunction : Priority.UserFunction;
     const trafficRules = mergedConfig?.rateLimit ? getTrafficRulesConfig(mergedConfig.rateLimit) : undefined;

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

@@ -1,4 +1,4 @@
-import type { Declaration, Expression, Statement } from '@babel/types';
+import type { Declaration, Expression, ObjectExpression, Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config/index.js';
 import type { BindingMethod } from './bindings.js';
 /**
@@ -11,9 +11,15 @@ import type { BindingMethod } from './bindings.js';
  *    declarations are found, this is ESM; if not, this is CJS
  */
 export declare const traverseNodes: (nodes: Statement[], getAllBindings: BindingMethod) => {
-    configExport: Record<string, unknown>;
+    configExport: Record<string, unknown> | undefined;
     handlerExports: ISCExport[];
     hasDefaultExport: boolean;
     defaultExportExpression: Expression | Declaration | undefined;
     inputModuleFormat: "cjs";
 };
+/**
+ * Takes an object expression node and returns the object resulting from the
+ * subtree. Only values supported by the `parsePrimitive` method are returned,
+ * and any others will be ignored and excluded from the resulting object.
+ */
+export declare const parseObject: (node: ObjectExpression) => Record<string, unknown>;

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

@@ -11,7 +11,7 @@ import { isESMImportExport, isModuleExports } from './helpers.js';
  */
 export const traverseNodes = (nodes, getAllBindings) => {
     const handlerExports = [];
-    let configExport = {};
+    let configExport;
     let hasDefaultExport = false;
     let defaultExportExpression;
     let inputModuleFormat = MODULE_FORMAT.COMMONJS;
@@ -142,7 +142,7 @@ const parseConfigESMExport = (node) => {
  * subtree. Only values supported by the `parsePrimitive` method are returned,
  * and any others will be ignored and excluded from the resulting object.
  */
-const parseObject = (node) => node.properties.reduce((acc, property) => {
+export const parseObject = (node) => node.properties.reduce((acc, property) => {
     if (property.type === 'ObjectProperty' && property.key.type === 'Identifier') {
         return {
             ...acc,

package/dist/utils/format_result.d.ts

@@ -4,10 +4,13 @@ import type { ExtendedRoute, Route } from './routes.js';
 export type FunctionResult = Omit<FunctionArchive, 'runtime'> & {
     bootstrapVersion?: string;
     eventSubscriptions?: string[];
+    memory?: number;
+    region?: string;
     routes?: ExtendedRoute[];
     excludedRoutes?: Route[];
     runtime: RuntimeName;
     schedule?: string;
     runtimeAPIVersion?: number;
+    vcpu?: number;
 };
 export declare const formatZipResult: (archive: FunctionArchive) => FunctionResult;

package/dist/utils/format_result.js

@@ -1,6 +1,8 @@
 import { removeUndefined } from './remove_undefined.js';
 // Takes the result of zipping a function and formats it for output.
 export const formatZipResult = (archive) => {
+    const memory = archive.staticAnalysisResult?.config?.memory ?? archive?.config?.memory;
+    const vcpu = archive.staticAnalysisResult?.config?.vcpu ?? archive?.config?.vcpu;
     const functionResult = {
         ...archive,
         staticAnalysisResult: undefined,
@@ -8,8 +10,11 @@ export const formatZipResult = (archive) => {
         routes: archive.staticAnalysisResult?.routes,
         excludedRoutes: archive.staticAnalysisResult?.excludedRoutes,
         runtime: archive.runtime.name,
+        memory,
+        region: archive.staticAnalysisResult?.config?.region ?? archive?.config?.region,
         schedule: archive.staticAnalysisResult?.config?.schedule ?? archive?.config?.schedule,
         runtimeAPIVersion: archive.staticAnalysisResult?.runtimeAPIVersion,
+        vcpu,
     };
     return removeUndefined(functionResult);
 };

package/dist/utils/parse_memory.d.ts

@@ -0,0 +1 @@
+export declare const parseMemoryMB: (input: number | string) => number;

package/dist/utils/parse_memory.js

@@ -0,0 +1,17 @@
+const MEMORY_UNIT_TO_MB = { mb: 1, gb: 1024 };
+const MEMORY_PATTERN = /^(\d+(?:\.\d+)?)\s*(mb|gb)?$/;
+// Accepts a bare number (interpreted as MB), a numeric string (`"2048"`), or
+// a human-friendly size with a unit (`"2gb"`, `"1024mb"`, case-insensitive).
+// Returns a normalized integer megabyte count.
+export const parseMemoryMB = (input) => {
+    if (typeof input === 'number') {
+        return input;
+    }
+    const match = MEMORY_PATTERN.exec(input.trim().toLowerCase());
+    if (!match) {
+        return Number.NaN;
+    }
+    const value = parseFloat(match[1]);
+    const unit = match[2] || 'mb';
+    return value * MEMORY_UNIT_TO_MB[unit];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "14.5.6",
+  "version": "14.7.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -44,7 +44,7 @@
     "@babel/parser": "^7.22.5",
     "@babel/types": "^7.28.5",
     "@netlify/binary-info": "^1.0.0",
-    "@netlify/serverless-functions-api": "2.15.1",
+    "@netlify/serverless-functions-api": "2.16.0",
     "@vercel/nft": "0.29.4",
     "archiver": "^7.0.0",
     "common-path-prefix": "^3.0.0",
@@ -75,6 +75,7 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@netlify/types": "2.7.0",
     "@types/archiver": "6.0.4",
     "@types/is-ci": "3.0.4",
     "@types/node": "20.19.33",
@@ -99,5 +100,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "0f6098d436437ff65fa97f6c191137f83e42918c"
+  "gitHead": "0e2b212c4ffae1e07159374df9991584e5b4bb0b"
 }