@vercel/build-utils 14.10.2 → 14.12.0

package/dist/lambda.d.ts

@@ -87,6 +87,7 @@ export interface LambdaOptionsWithZipBuffer extends LambdaOptionsBase {
 interface GetLambdaOptionsFromFunctionOptions {
     sourceFile: string;
     config?: Pick<Config, 'functions' | 'serviceName'>;
+    isScheduleEntrypoint?: boolean;
 }
 export declare class Lambda {
     type: 'Lambda';
@@ -161,4 +162,4 @@ export declare class Lambda {
  */
 export declare function createLambda(opts: LambdaOptions): Promise<Lambda>;
 export declare function createZip(files: Files): Promise<Buffer>;
-export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'architecture' | 'memory' | 'maxDuration' | 'affinity' | 'maxConcurrency' | 'regions' | 'functionFailoverRegions' | 'experimentalTriggers' | 'supportsCancellation'>>;
+export declare function getLambdaOptionsFromFunction({ sourceFile, config, isScheduleEntrypoint, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'architecture' | 'memory' | 'maxDuration' | 'affinity' | 'maxConcurrency' | 'regions' | 'functionFailoverRegions' | 'experimentalTriggers' | 'supportsCancellation'>>;

package/dist/lambda.js

@@ -360,7 +360,8 @@ async function createZip(files) {
 }
 async function getLambdaOptionsFromFunction({
   sourceFile,
-  config
+  config,
+  isScheduleEntrypoint = false
 }) {
   if (config?.functions) {
     const serviceName = typeof config.serviceName === "string" && config.serviceName !== "" ? config.serviceName : void 0;
@@ -385,6 +386,11 @@ async function getLambdaOptionsFromFunction({
             `functions["${pattern}"].experimentalTriggers can only have one item for queue/v2beta`
           );
         }
+        if (isScheduleEntrypoint && experimentalTriggers !== void 0 && !(experimentalTriggers.length === 1 && experimentalTriggers[0]?.type === "schedule/v1beta")) {
+          throw new Error(
+            `functions["${pattern}"].experimentalTriggers conflicts with the schedule entrypoint trigger`
+          );
+        }
         return {
           architecture: fn.architecture,
           memory: fn.memory,
@@ -393,13 +399,13 @@ async function getLambdaOptionsFromFunction({
           maxConcurrency: fn.maxConcurrency,
           regions: fn.regions,
           functionFailoverRegions: fn.functionFailoverRegions,
-          experimentalTriggers,
+          experimentalTriggers: isScheduleEntrypoint ? [{ type: "schedule/v1beta" }] : experimentalTriggers,
           supportsCancellation: fn.supportsCancellation
         };
       }
     }
   }
-  return {};
+  return isScheduleEntrypoint ? { experimentalTriggers: [{ type: "schedule/v1beta" }] } : {};
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/prerender.d.ts

@@ -22,6 +22,7 @@ export interface PrerenderInitialMetadata {
      */
     htmlSize?: number;
 }
+export type PrerenderOnMiss = 'sync' | 'dynamic';
 interface PrerenderOptions {
     expiration: number | false;
     staleExpiration?: number;
@@ -41,6 +42,7 @@ interface PrerenderOptions {
     exposeErrBody?: boolean;
     partialFallback?: boolean;
     initialMetadata?: PrerenderInitialMetadata;
+    onMiss?: PrerenderOnMiss;
 }
 export declare class Prerender {
     type: 'Prerender';
@@ -77,6 +79,8 @@ export declare class Prerender {
      * from frameworks that predate the field carry none.
      */
     initialMetadata?: PrerenderInitialMetadata;
-    constructor({ expiration, staleExpiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, exposeErrBody, partialFallback, initialMetadata, }: PrerenderOptions);
+    /** Serving mode when no prerendered output exists yet. Absent means `sync`. Interpreted by the proxy; carried unvalidated. */
+    onMiss?: PrerenderOnMiss;
+    constructor({ expiration, staleExpiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, exposeErrBody, partialFallback, initialMetadata, onMiss, }: PrerenderOptions);
 }
 export {};

package/dist/prerender.js

@@ -40,13 +40,15 @@ class Prerender {
     chain,
     exposeErrBody,
     partialFallback,
-    initialMetadata
+    initialMetadata,
+    onMiss
   }) {
     this.type = "Prerender";
     this.expiration = expiration;
     this.staleExpiration = staleExpiration;
     this.sourcePath = sourcePath;
     this.initialMetadata = initialMetadata;
+    this.onMiss = onMiss;
     this.lambda = lambda;
     if (this.lambda) {
       this.lambda.operationType = this.lambda.operationType || "ISR";

package/dist/schedule-path-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const SCHEDULE_FUNCTION_PREFIX = "_vercel/schedules";
+/** Build-output path for a function generated from a schedule entrypoint. */
+export declare function getScheduleFunctionPath(entrypointSegments: string[]): string;

package/dist/schedule-path-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schedule_path_utils_exports = {};
+__export(schedule_path_utils_exports, {
+  SCHEDULE_FUNCTION_PREFIX: () => SCHEDULE_FUNCTION_PREFIX,
+  getScheduleFunctionPath: () => getScheduleFunctionPath
+});
+module.exports = __toCommonJS(schedule_path_utils_exports);
+const SCHEDULE_FUNCTION_PREFIX = "_vercel/schedules";
+function getScheduleFunctionPath(entrypointSegments) {
+  if (entrypointSegments.length === 0 || entrypointSegments.some(
+    (segment) => !segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\")
+  )) {
+    throw new Error("Schedule function paths require safe, non-empty segments");
+  }
+  return [SCHEDULE_FUNCTION_PREFIX, ...entrypointSegments].join("/");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SCHEDULE_FUNCTION_PREFIX,
+  getScheduleFunctionPath
+});

package/dist/types.d.ts

@@ -21,6 +21,25 @@ export interface FileBase {
 export interface Files {
     [filePath: string]: File;
 }
+export interface ScheduleFunctionEntrypoint {
+    /** Runtime-specific entrypoint locator from `vercel.json`. */
+    entrypoint: string;
+    /** Project-relative source file that contains the entrypoint. */
+    sourceFile: string;
+    /** Names of the schedules that dispatch to this entrypoint, in config order. */
+    scheduleNames: string[];
+}
+/**
+ * One function built from schedule entrypoints. Runtimes that pack several
+ * entrypoints into a single function receive them all here and dispatch on
+ * the schedule name at runtime; runtimes that build one function per
+ * entrypoint receive exactly one.
+ */
+export interface ScheduleFunctionBuildConfig {
+    /** Function output path every schedule in this build targets. */
+    outputPath: string;
+    entrypoints: [ScheduleFunctionEntrypoint, ...ScheduleFunctionEntrypoint[]];
+}
 export interface Config {
     bunVersion?: string;
     maxLambdaSize?: string;
@@ -52,6 +71,8 @@ export interface Config {
     serviceName?: string;
     /** Buildpack runtime slug (e.g. "ruby"). */
     buildpack?: string;
+    /** Set when this build produces a function for schedule entrypoints. */
+    scheduleFunction?: ScheduleFunctionBuildConfig;
     [key: string]: unknown;
 }
 export type { HasField };
@@ -464,6 +485,56 @@ export interface DevSubscriber {
 export type DevSidecar = DevSubscriber;
 /** Returns additional processes that a builder needs alongside its primary dev server. */
 export type GetDevSidecars = (options: GetDevSidecarsOptions) => Promise<DevSidecar[]>;
+/** A deployment function identity and its local execution target. */
+export interface DevFunction {
+    /** Build output function path, without a leading slash or .func suffix. */
+    outputPath: string;
+    /** Source path relative to workPath, when this is a source-backed function. */
+    sourceFile?: string;
+    invocation: {
+        type: 'http';
+        /** Root-relative pathname within the owning dev server, including basePath. */
+        pathname: string;
+    } | {
+        type: 'entrypoint';
+        /** Select this builder entrypoint directly, without public URL routing. */
+        entrypoint: string;
+    };
+    /** Normalized deployment trigger metadata, including Queue consumer identity. */
+    experimentalTriggers?: TriggerEvent[];
+}
+export interface GetDevManifestOptions {
+    /** Absolute project or service root. */
+    workPath: string;
+    /** Original builder entry, before source expansion or dev-command filtering. */
+    build: Builder;
+    /** Real source paths relative to workPath, using forward slashes. No aliases. */
+    files: string[];
+    /** Resolved authored configuration for this scope, including functions. */
+    config: Config;
+    /** Effective development environment. Do not mutate this object. */
+    env: Env;
+}
+export interface DevManifest {
+    /** Complete replacement snapshot for the invoking builder scope. */
+    functions: DevFunction[];
+    /** Native framework schedules, using the static Build Output API schema. */
+    schedules?: Schedule[];
+    /** Authored functions keys resolved by this provider, for unmatched diagnostics. */
+    matchedFunctionPatterns: string[];
+}
+/**
+ * Discover deployment function identities and optional native schedules without
+ * starting an application server, scheduler, or delivery loop. The host owns
+ * runtime origins, readiness, and trigger registration. Functions do not need a
+ * Queue trigger to be discoverable; direct Schedule targets use outputPath.
+ * Called before framework builders are filtered for a native dev command, and
+ * again on source/config/environment changes. An empty snapshot removes this
+ * owner's registrations. Errors must leave the last valid snapshot in place.
+ * An absent hook permits the host's conventional per-entrypoint fallback; an
+ * explicitly empty manifest is authoritative and must not enable that fallback.
+ */
+export type GetDevManifest = (options: GetDevManifestOptions) => Promise<DevManifest>;
 export interface BuilderVX {
     version: -1;
     build: BuildVX;
@@ -472,6 +543,7 @@ export interface BuilderVX {
     shouldServe?: ShouldServe;
     startDevServer?: StartDevServer;
     getDevSidecars?: GetDevSidecars;
+    getDevManifest?: GetDevManifest;
 }
 export interface BuilderV2 {
     version: 2;
@@ -481,6 +553,7 @@ export interface BuilderV2 {
     shouldServe?: ShouldServe;
     startDevServer?: StartDevServer;
     getDevSidecars?: GetDevSidecars;
+    getDevManifest?: GetDevManifest;
 }
 export interface BuilderV3 {
     version: 3;
@@ -490,6 +563,7 @@ export interface BuilderV3 {
     shouldServe?: ShouldServe;
     startDevServer?: StartDevServer;
     getDevSidecars?: GetDevSidecars;
+    getDevManifest?: GetDevManifest;
 }
 type ImageFormat = 'image/avif' | 'image/webp';
 type ImageContentDispositionType = 'inline' | 'attachment';

package/package.json

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