@vercel/build-utils 13.26.0 → 13.26.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @vercel/build-utils
 
+## 13.26.2
+
+### Patch Changes
+
+- 647c1e8: Cleanup getLambdaSupportsStreaming
+
+## 13.26.1
+
+### Patch Changes
+
+- fa25cb7: Fix config.framework in deserializeBuildOutput
+- 972cc84: Support workflow-triggered job services in queue infrastructure
+
+  Add `isWorkflowTriggeredService()` and `isQueueBackedService()` helpers so workflow services
+  are recognized by the queue broker, dev server, and build pipeline. Update Python runtime to
+  bootstrap workflow services as queue-backed workers.
+
 ## 13.26.0
 
 ### Minor Changes

package/dist/deserialize/deserialize-build-output-types.d.ts

@@ -35,7 +35,7 @@ export type GroupLambdasOptions = {
 export type DeserializeBuildOutputLambda<TLambda extends Lambda> = (files: Files, config: SerializedLambda | SerializedNodejsLambda, repoRootPath: string, fileFsRefsCache: Map<string, FileFsRef>, options?: DeserializeBuildOutputLambdaOptions) => Promise<TLambda>;
 export type GroupLambdas<TLambda extends Lambda> = (lambdas: Record<string, TLambda>, options: GroupLambdasOptions) => Promise<Record<string, TLambda>>;
 export type InspectSerializedLambda = (path: string, config: SerializedLambda | SerializedNodejsLambda, repoRootPath: string, hasServerActions: boolean) => Promise<boolean>;
-export interface DeserializeBuildOutputOptions<TResult extends DeserializeBuildOutputResult = DeserializeBuildOutputResult, TLambda extends Lambda = Lambda> {
+export interface DeserializeBuildOutputOptions<TMeta = unknown, TLambda extends Lambda = Lambda> {
     outputDir: string;
     repoRootPath: string;
     maxBundleSizeMb?: number;
@@ -47,9 +47,7 @@ export interface DeserializeBuildOutputOptions<TResult extends DeserializeBuildO
     inspectSerializedLambda?: InspectSerializedLambda;
     warn?: (message: string) => void;
     includeDeploymentId?: boolean;
-    getMeta?: (hasServerActions: boolean) => TResult extends {
-        meta?: infer TMeta;
-    } ? TMeta : never;
+    getMeta?: (hasServerActions: boolean) => TMeta;
 }
 export type DeserializeBuildOutputFiles = BuildResultV2Typical['output'];
 export type DeserializeBuildOutputPrerenderFallback = Prerender['fallback'];

package/dist/deserialize/deserialize-build-output.d.ts

@@ -1,4 +1,4 @@
 import type { Lambda } from '../lambda';
-import type { DeserializeBuildOutputConfig, DeserializeBuildOutputOptions, DeserializeBuildOutputResult } from './deserialize-build-output-types';
+import type { DeserializeBuildOutputOptions, DeserializeBuildOutputResult } from './deserialize-build-output-types';
 export declare function validateDeploymentId(deploymentId?: string): void;
-export declare function deserializeBuildOutput<TConfig extends DeserializeBuildOutputConfig = DeserializeBuildOutputConfig, TResult extends DeserializeBuildOutputResult = DeserializeBuildOutputResult, TLambda extends Lambda = Lambda>(options: DeserializeBuildOutputOptions<TResult, TLambda>): Promise<TResult>;
+export declare function deserializeBuildOutput<TFlags = unknown, TMeta = unknown, TLambda extends Lambda = Lambda>(options: DeserializeBuildOutputOptions<TMeta, TLambda>): Promise<DeserializeBuildOutputResult<TFlags, TMeta>>;

package/dist/deserialize/deserialize-build-output.js

@@ -186,9 +186,7 @@ async function deserializeBuildOutput(options) {
     );
   }
   validateDeploymentId(config.deploymentId);
-  const flags = await (0, import_maybe_read_json.maybeReadJSON)(
-    (0, import_path.join)(outputDir, "flags.json")
-  );
+  const flags = await (0, import_maybe_read_json.maybeReadJSON)((0, import_path.join)(outputDir, "flags.json"));
   const staticDir = (0, import_path.join)(outputDir, "static");
   const output = await (0, import_glob.default)("**", {
     cwd: staticDir,
@@ -276,7 +274,7 @@ async function deserializeBuildOutput(options) {
     }
   );
   applyGroupedLambdas(output, groupedLambdas);
-  const framework = (0, import_validate_framework_version.validateFrameworkVersion)(config?.framework?.version);
+  const framework = (0, import_validate_framework_version.validateFrameworkVersion)(config?.framework);
   const meta = getMeta?.(hasServerActions);
   return {
     wildcard: config.wildcard,

package/dist/deserialize/validate-framework-version.d.ts

@@ -1,5 +1,6 @@
 type FrameworkMeta = {
+    slug: string;
     version: string;
 };
-export declare function validateFrameworkVersion(frameworkVersion: string | undefined): FrameworkMeta | undefined;
+export declare function validateFrameworkVersion(framework: FrameworkMeta | undefined): FrameworkMeta | undefined;
 export {};

package/dist/deserialize/validate-framework-version.js

@@ -22,30 +22,40 @@ __export(validate_framework_version_exports, {
 });
 module.exports = __toCommonJS(validate_framework_version_exports);
 var import_errors = require("../errors");
+const MAX_SLUG_LENGTH = 50;
 const MAX_FRAMEWORK_VERSION_LENGTH = 50;
-function validateFrameworkVersion(frameworkVersion) {
-  if (!frameworkVersion) {
+function validateFrameworkVersion(framework) {
+  if (!framework) {
     return void 0;
   }
-  if (typeof frameworkVersion !== "string") {
+  const { slug, version } = framework;
+  if (typeof slug !== "string") {
+    return void 0;
+  }
+  if (typeof version !== "string") {
     throw new import_errors.NowBuildError({
-      message: `Invalid config.json: "framework.version" type "${typeof frameworkVersion}" should be "string"`,
+      message: `Invalid config.json: "version" type "${typeof version}" should be "string"`,
       code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_VERSION_TYPE"
     });
   }
-  if (frameworkVersion.length > MAX_FRAMEWORK_VERSION_LENGTH) {
-    const trimmedFrameworkVersion = frameworkVersion.slice(
+  if (slug.length > MAX_SLUG_LENGTH) {
+    const trimmedFrameworkSlug = slug.slice(0, MAX_SLUG_LENGTH);
+    throw new import_errors.NowBuildError({
+      message: `Invalid config.json: "framework.slug" length ${slug.length} > ${MAX_SLUG_LENGTH}. "${trimmedFrameworkSlug}..."`,
+      code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_SLUG_LENGTH"
+    });
+  }
+  if (version.length > MAX_FRAMEWORK_VERSION_LENGTH) {
+    const trimmedFrameworkVersion = version.slice(
       0,
       MAX_FRAMEWORK_VERSION_LENGTH
     );
     throw new import_errors.NowBuildError({
-      message: `Invalid config.json: "framework.version" length ${frameworkVersion.length} > ${MAX_FRAMEWORK_VERSION_LENGTH}. "${trimmedFrameworkVersion}..."`,
+      message: `Invalid config.json: "framework.version" length ${version.length} > ${MAX_FRAMEWORK_VERSION_LENGTH}. "${trimmedFrameworkVersion}..."`,
       code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_VERSION_LENGTH"
     });
   }
-  return {
-    version: frameworkVersion
-  };
+  return framework;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/finalize-lambda.d.ts

@@ -1,7 +1,6 @@
 import type { Lambda } from './lambda';
 import type { NodejsLambda } from './nodejs-lambda';
 import type { BytecodeCachingOptions } from './process-serverless/get-lambda-preload-scripts';
-import type { SupportsStreamingResult } from './process-serverless/get-lambda-supports-streaming';
 /**
  * Optional wrapper around async work, allowing callers to inject tracing
  * (e.g. dd-trace spans) without coupling the shared code to a tracer.
@@ -59,8 +58,6 @@ export interface FinalizeLambdaResult {
     /** Compressed size in bytes. */
     size: number;
     uncompressedBytes: number;
-    /** Non-fatal streaming detection error, if any. Caller decides how to log. */
-    streamingError?: SupportsStreamingResult['error'];
 }
 /**
  * Core Lambda finalization logic shared between BYOF and build-container.

package/dist/finalize-lambda.js

@@ -98,18 +98,17 @@ async function finalizeLambda(params) {
       bytecodeCachingOptions
     )
   };
-  const streamingResult = await (0, import_get_lambda_supports_streaming.getLambdaSupportsStreaming)(
+  const streamingResult = (0, import_get_lambda_supports_streaming.getLambdaSupportsStreaming)(
     lambda,
     forceStreamingRuntime
   );
-  lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
+  lambda.supportsResponseStreaming = streamingResult;
   return {
     buffer: zipResult.buffer,
     zipPath: zipResult.zipPath ?? null,
     digest: zipResult.digest,
     size: zipResult.size,
-    uncompressedBytes,
-    streamingError: streamingResult.error
+    uncompressedBytes
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.d.ts

@@ -43,7 +43,7 @@ export * from './service-path-utils';
 export { getEncryptedEnv, type EncryptedEnvFile, } from './process-serverless/get-encrypted-env-file';
 export { getLambdaEnvironment } from './process-serverless/get-lambda-environment';
 export { getLambdaPreloadScripts, type BytecodeCachingOptions, } from './process-serverless/get-lambda-preload-scripts';
-export { getLambdaSupportsStreaming, type SupportsStreamingResult, } from './process-serverless/get-lambda-supports-streaming';
+export { getLambdaSupportsStreaming } from './process-serverless/get-lambda-supports-streaming';
 export { streamToDigestAsync, sha256, md5, type FileDigest, } from './fs/stream-to-digest-async';
 export { getBuildResultMetadata, type BuildResultMetadata, } from './collect-build-result/get-build-result-metadata';
 export { validateBuildResult, SUPPORTED_AL2023_RUNTIMES, type ValidateBuildResultParams, type ValidateBuildResultResult, } from './collect-build-result/validate-build-result';

package/dist/index.js

@@ -34586,10 +34586,12 @@ __export(src_exports, {
   isNodeEntrypoint: () => isNodeEntrypoint,
   isPythonEntrypoint: () => isPythonEntrypoint,
   isPythonFramework: () => isPythonFramework,
+  isQueueBackedService: () => isQueueBackedService,
   isQueueTriggeredService: () => isQueueTriggeredService,
   isRouteMiddleware: () => isRouteMiddleware,
   isScheduleTriggeredService: () => isScheduleTriggeredService,
   isSymbolicLink: () => isSymbolicLink,
+  isWorkflowTriggeredService: () => isWorkflowTriggeredService,
   manifestPath: () => manifestPath,
   maybeReadJSON: () => maybeReadJSON,
   md5: () => md5,
@@ -35824,6 +35826,12 @@ function isQueueTriggeredService(service) {
 function isScheduleTriggeredService(service) {
   return service.type === "cron" || service.type === "job" && service.trigger === "schedule";
 }
+function isWorkflowTriggeredService(service) {
+  return service.type === "job" && service.trigger === "workflow";
+}
+function isQueueBackedService(service) {
+  return isQueueTriggeredService(service) || isWorkflowTriggeredService(service);
+}
 function getReportedServiceType(service) {
   switch (service.type) {
     case "web":
@@ -39319,20 +39327,20 @@ function getLambdaEnvironment(lambda, buffer, options) {
 }
 
 // src/process-serverless/get-lambda-supports-streaming.ts
-async function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
+function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
   if (lambda.awsLambdaHandler) {
-    return { supportsStreaming: false };
+    return false;
   }
   if (forceStreamingRuntime) {
-    return { supportsStreaming: true };
+    return true;
   }
   if (typeof lambda.supportsResponseStreaming === "boolean") {
-    return { supportsStreaming: lambda.supportsResponseStreaming };
+    return lambda.supportsResponseStreaming;
   }
   if ("launcherType" in lambda && lambda.launcherType === "Nodejs") {
-    return { supportsStreaming: true };
+    return true;
   }
-  return { supportsStreaming: void 0 };
+  return void 0;
 }
 
 // src/fs/stream-to-digest-async.ts
@@ -39702,18 +39710,17 @@ async function finalizeLambda(params) {
       bytecodeCachingOptions
     )
   };
-  const streamingResult = await getLambdaSupportsStreaming(
+  const streamingResult = getLambdaSupportsStreaming(
     lambda,
     forceStreamingRuntime
   );
-  lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
+  lambda.supportsResponseStreaming = streamingResult;
   return {
     buffer: zipResult.buffer,
     zipPath: zipResult.zipPath ?? null,
     digest: zipResult.digest,
     size: zipResult.size,
-    uncompressedBytes,
-    streamingError: streamingResult.error
+    uncompressedBytes
   };
 }
 
@@ -39787,30 +39794,40 @@ function validateEnvWrapperSupport(encryptedEnvFilename, encryptedEnvContent, la
 }
 
 // src/deserialize/validate-framework-version.ts
+var MAX_SLUG_LENGTH = 50;
 var MAX_FRAMEWORK_VERSION_LENGTH = 50;
-function validateFrameworkVersion(frameworkVersion) {
-  if (!frameworkVersion) {
+function validateFrameworkVersion(framework) {
+  if (!framework) {
+    return void 0;
+  }
+  const { slug, version } = framework;
+  if (typeof slug !== "string") {
     return void 0;
   }
-  if (typeof frameworkVersion !== "string") {
+  if (typeof version !== "string") {
     throw new NowBuildError({
-      message: `Invalid config.json: "framework.version" type "${typeof frameworkVersion}" should be "string"`,
+      message: `Invalid config.json: "version" type "${typeof version}" should be "string"`,
       code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_VERSION_TYPE"
     });
   }
-  if (frameworkVersion.length > MAX_FRAMEWORK_VERSION_LENGTH) {
-    const trimmedFrameworkVersion = frameworkVersion.slice(
+  if (slug.length > MAX_SLUG_LENGTH) {
+    const trimmedFrameworkSlug = slug.slice(0, MAX_SLUG_LENGTH);
+    throw new NowBuildError({
+      message: `Invalid config.json: "framework.slug" length ${slug.length} > ${MAX_SLUG_LENGTH}. "${trimmedFrameworkSlug}..."`,
+      code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_SLUG_LENGTH"
+    });
+  }
+  if (version.length > MAX_FRAMEWORK_VERSION_LENGTH) {
+    const trimmedFrameworkVersion = version.slice(
       0,
       MAX_FRAMEWORK_VERSION_LENGTH
     );
     throw new NowBuildError({
-      message: `Invalid config.json: "framework.version" length ${frameworkVersion.length} > ${MAX_FRAMEWORK_VERSION_LENGTH}. "${trimmedFrameworkVersion}..."`,
+      message: `Invalid config.json: "framework.version" length ${version.length} > ${MAX_FRAMEWORK_VERSION_LENGTH}. "${trimmedFrameworkVersion}..."`,
       code: "VC_BUILD_INVALID_CONFIG_JSON_FRAMEWORK_VERSION_LENGTH"
     });
   }
-  return {
-    version: frameworkVersion
-  };
+  return framework;
 }
 
 // src/deserialize/hydrate-files-map.ts
@@ -40040,9 +40057,7 @@ async function deserializeBuildOutput(options) {
     );
   }
   validateDeploymentId(config.deploymentId);
-  const flags = await maybeReadJSON(
-    (0, import_path15.join)(outputDir, "flags.json")
-  );
+  const flags = await maybeReadJSON((0, import_path15.join)(outputDir, "flags.json"));
   const staticDir = (0, import_path15.join)(outputDir, "static");
   const output = await glob("**", {
     cwd: staticDir,
@@ -40130,7 +40145,7 @@ async function deserializeBuildOutput(options) {
     }
   );
   applyGroupedLambdas(output, groupedLambdas);
-  const framework = validateFrameworkVersion(config?.framework?.version);
+  const framework = validateFrameworkVersion(config?.framework);
   const meta = getMeta?.(hasServerActions);
   return {
     wildcard: config.wildcard,
@@ -40381,10 +40396,12 @@ function getExtendedPayload({
   isNodeEntrypoint,
   isPythonEntrypoint,
   isPythonFramework,
+  isQueueBackedService,
   isQueueTriggeredService,
   isRouteMiddleware,
   isScheduleTriggeredService,
   isSymbolicLink,
+  isWorkflowTriggeredService,
   manifestPath,
   maybeReadJSON,
   md5,

package/dist/process-serverless/get-lambda-supports-streaming.d.ts

@@ -5,13 +5,6 @@ interface LambdaLike {
     runtime: string;
     supportsResponseStreaming?: boolean;
 }
-export interface SupportsStreamingResult {
-    supportsStreaming: boolean | undefined;
-    error?: {
-        handler: string;
-        message: string;
-    };
-}
 /**
  * Determines if a Lambda should have streaming enabled.
  *
@@ -25,5 +18,5 @@ export interface SupportsStreamingResult {
  * enabled. If the setting is defined it will be honored. Enabled by
  * default for Node.js.
  */
-export declare function getLambdaSupportsStreaming(lambda: LambdaLike, forceStreamingRuntime: boolean): Promise<SupportsStreamingResult>;
+export declare function getLambdaSupportsStreaming(lambda: LambdaLike, forceStreamingRuntime: boolean): boolean | undefined;
 export {};

package/dist/process-serverless/get-lambda-supports-streaming.js

@@ -21,20 +21,20 @@ __export(get_lambda_supports_streaming_exports, {
   getLambdaSupportsStreaming: () => getLambdaSupportsStreaming
 });
 module.exports = __toCommonJS(get_lambda_supports_streaming_exports);
-async function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
+function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
   if (lambda.awsLambdaHandler) {
-    return { supportsStreaming: false };
+    return false;
   }
   if (forceStreamingRuntime) {
-    return { supportsStreaming: true };
+    return true;
   }
   if (typeof lambda.supportsResponseStreaming === "boolean") {
-    return { supportsStreaming: lambda.supportsResponseStreaming };
+    return lambda.supportsResponseStreaming;
   }
   if ("launcherType" in lambda && lambda.launcherType === "Nodejs") {
-    return { supportsStreaming: true };
+    return true;
   }
-  return { supportsStreaming: void 0 };
+  return void 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/types.d.ts

@@ -550,6 +550,15 @@ export declare function isScheduleTriggeredService(service: {
     type?: ServiceType;
     trigger?: JobTrigger;
 }): boolean;
+export declare function isWorkflowTriggeredService(service: {
+    type?: ServiceType;
+    trigger?: JobTrigger;
+}): boolean;
+/** Returns true for any service that consumes queue messages (worker, queue-triggered job, workflow-triggered job). */
+export declare function isQueueBackedService(service: {
+    type?: ServiceType;
+    trigger?: JobTrigger;
+}): boolean;
 export type ReportedServiceType = 'web' | 'schedule' | 'queue' | 'workflow';
 export declare function getReportedServiceType(service: {
     type?: ServiceType;

package/dist/types.js

@@ -25,8 +25,10 @@ __export(types_exports, {
   getReportedServiceType: () => getReportedServiceType,
   getServiceQueueTopicConfigs: () => getServiceQueueTopicConfigs,
   getServiceQueueTopics: () => getServiceQueueTopics,
+  isQueueBackedService: () => isQueueBackedService,
   isQueueTriggeredService: () => isQueueTriggeredService,
-  isScheduleTriggeredService: () => isScheduleTriggeredService
+  isScheduleTriggeredService: () => isScheduleTriggeredService,
+  isWorkflowTriggeredService: () => isWorkflowTriggeredService
 });
 module.exports = __toCommonJS(types_exports);
 class Version {
@@ -69,6 +71,12 @@ function isQueueTriggeredService(service) {
 function isScheduleTriggeredService(service) {
   return service.type === "cron" || service.type === "job" && service.trigger === "schedule";
 }
+function isWorkflowTriggeredService(service) {
+  return service.type === "job" && service.trigger === "workflow";
+}
+function isQueueBackedService(service) {
+  return isQueueTriggeredService(service) || isWorkflowTriggeredService(service);
+}
 function getReportedServiceType(service) {
   switch (service.type) {
     case "web":
@@ -98,6 +106,8 @@ function getReportedServiceType(service) {
   getReportedServiceType,
   getServiceQueueTopicConfigs,
   getServiceQueueTopics,
+  isQueueBackedService,
   isQueueTriggeredService,
-  isScheduleTriggeredService
+  isScheduleTriggeredService,
+  isWorkflowTriggeredService
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.26.0",
+  "version": "13.26.2",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",