@vercel/build-utils 13.19.1 → 13.21.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @vercel/build-utils
 
+## 13.21.0
+
+### Minor Changes
+
+- c56f851: Upgrade to TypeScript 5.9
+
+### Patch Changes
+
+- Updated dependencies [8e999cb]
+  - @vercel/python-analysis@0.11.1
+
+## 13.20.0
+
+### Minor Changes
+
+- Add framework to package manifest for python and backends builders. ([#16072](https://github.com/vercel/vercel/pull/16072))
+
+### Patch Changes
+
+- Add shared build output deserialization helpers for existing callers. ([#16072](https://github.com/vercel/vercel/pull/16072))
+
 ## 13.19.1
 
 ### Patch Changes

package/dist/collect-build-result/stream-with-extended-payload.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export interface ExtendedBodyData {
     prefix: string;
     suffix: string;

package/dist/collect-build-result/validate-regular-file.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type FileFsRef from '../file-fs-ref';
 import { type Stats } from 'fs-extra';
 interface FileLike {

package/dist/collect-uncompressed-size.d.ts

@@ -3,4 +3,4 @@ import type { Files } from './types';
  * Collects the total uncompressed size of a set of Lambda files.
  * Handles both FileBlob (in-memory) and FileFsRef (on-disk) file types.
  */
-export declare const collectUncompressedSize: (files: Files, ignoreFn?: ((fileKey: string) => boolean) | undefined) => Promise<number>;
+export declare const collectUncompressedSize: (files: Files, ignoreFn?: (fileKey: string) => boolean) => Promise<number>;

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

@@ -0,0 +1,57 @@
+import type FileFsRef from '../file-fs-ref';
+import type { Lambda } from '../lambda';
+import type { Prerender } from '../prerender';
+import type { BuildResultV2Typical, Files } from '../types';
+import type { SerializedEdgeFunction, SerializedLambda, SerializedNodejsLambda, SerializedPrerender } from './serialized-types';
+export interface DeserializeBuildOutputPathOverride {
+    contentType?: string;
+    mode?: number;
+    path?: string;
+}
+export interface DeserializeBuildOutputConfig<TFlags = unknown> {
+    version?: 3;
+    wildcard?: BuildResultV2Typical['wildcard'];
+    images?: BuildResultV2Typical['images'];
+    routes?: BuildResultV2Typical['routes'];
+    overrides?: Record<string, DeserializeBuildOutputPathOverride>;
+    framework?: BuildResultV2Typical['framework'];
+    crons?: BuildResultV2Typical['crons'];
+    flags?: TFlags;
+    deploymentId?: string;
+}
+export type DeserializeBuildOutputResult<TFlags = unknown, TMeta = unknown> = Omit<BuildResultV2Typical, 'flags'> & {
+    flags?: TFlags;
+    meta?: TMeta;
+};
+export type DeserializeBuildOutputLambdaOptions = {
+    forceNodejsStreaming?: boolean;
+    useOnlyStreamingLambda?: boolean;
+};
+export type GroupLambdasOptions = {
+    force: 'all' | undefined;
+    maxBundleSizeMb: number | undefined;
+    debug: boolean | undefined;
+};
+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> {
+    outputDir: string;
+    repoRootPath: string;
+    maxBundleSizeMb?: number;
+    debugGroupLambdas?: boolean;
+    useOnlyStreamingLambda?: boolean;
+    forceNodejsStreaming?: boolean;
+    deserializeLambda: DeserializeBuildOutputLambda<TLambda>;
+    groupLambdas: GroupLambdas<TLambda>;
+    inspectSerializedLambda?: InspectSerializedLambda;
+    warn?: (message: string) => void;
+    includeDeploymentId?: boolean;
+    getMeta?: (hasServerActions: boolean) => TResult extends {
+        meta?: infer TMeta;
+    } ? TMeta : never;
+}
+export type DeserializeBuildOutputFiles = BuildResultV2Typical['output'];
+export type DeserializeBuildOutputPrerenderFallback = Prerender['fallback'];
+export type DeserializeBuildOutputSerializedConfig = SerializedEdgeFunction | SerializedLambda | SerializedNodejsLambda;
+export type DeserializeBuildOutputSerializedPrerender = SerializedPrerender;

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 deserialize_build_output_types_exports = {};
+module.exports = __toCommonJS(deserialize_build_output_types_exports);

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

@@ -0,0 +1,4 @@
+import type { Lambda } from '../lambda';
+import type { DeserializeBuildOutputConfig, 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>;

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

@@ -0,0 +1,297 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deserialize_build_output_exports = {};
+__export(deserialize_build_output_exports, {
+  deserializeBuildOutput: () => deserializeBuildOutput,
+  validateDeploymentId: () => validateDeploymentId
+});
+module.exports = __toCommonJS(deserialize_build_output_exports);
+var fs = __toESM(require("fs-extra"));
+var import_path = require("path");
+var import_errors = require("../errors");
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+var import_glob = __toESM(require("../fs/glob"));
+var import_prerender = require("../prerender");
+var import_create_functions_iterator = require("./create-functions-iterator");
+var import_deserialize_edge_function = require("./deserialize-edge-function");
+var import_maybe_read_json = require("./maybe-read-json");
+var import_validate_framework_version = require("./validate-framework-version");
+const MAX_DEPLOYMENT_ID_LENGTH = 32;
+const VALID_DEPLOYMENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function validateDeploymentId(deploymentId) {
+  if (deploymentId && deploymentId.length > MAX_DEPLOYMENT_ID_LENGTH) {
+    throw new import_errors.NowBuildError({
+      message: `The configured deploymentId "${deploymentId}" exceeds the maximum length of ${MAX_DEPLOYMENT_ID_LENGTH} characters. Please use a shorter deploymentId.`,
+      code: "VC_BUILD_INVALID_DEPLOYMENT_ID_LENGTH"
+    });
+  }
+  if (deploymentId && !VALID_DEPLOYMENT_ID_PATTERN.test(deploymentId)) {
+    throw new import_errors.NowBuildError({
+      message: `The configured deploymentId "${deploymentId}" contains invalid characters. Only alphanumeric characters (a-z, A-Z, 0-9), hyphens (-), and underscores (_) are allowed.`,
+      code: "VC_BUILD_INVALID_DEPLOYMENT_ID_CHARACTERS"
+    });
+  }
+}
+function applyOutputOverrides(output, overrides, warn) {
+  for (const [name, override] of Object.entries(overrides || {})) {
+    const entry = output[name];
+    if (entry) {
+      if (override.contentType) {
+        entry.contentType = override.contentType;
+      }
+      if (override.mode) {
+        entry.mode = override.mode;
+      }
+      if (override.path) {
+        output[override.path] = entry;
+        delete output[name];
+      }
+    } else {
+      warn?.(
+        `Warning: Override path "${name}" was not detected as an output path`
+      );
+    }
+  }
+}
+async function deserializePrerenderFallback(prerenderConfigPath, fallbackConfig) {
+  if (typeof fallbackConfig === "string") {
+    return import_file_fs_ref.default.fromFsPath({
+      fsPath: (0, import_path.join)((0, import_path.dirname)(prerenderConfigPath), fallbackConfig)
+    });
+  }
+  if (fallbackConfig) {
+    return import_file_fs_ref.default.fromFsPath({
+      mode: fallbackConfig.mode,
+      contentType: fallbackConfig.contentType,
+      fsPath: (0, import_path.join)((0, import_path.dirname)(prerenderConfigPath), fallbackConfig.fsPath)
+    });
+  }
+  return null;
+}
+function applyFunctionSymlinks(output, prerenders, functionSymlinks) {
+  for (const [path, target] of functionSymlinks.entries()) {
+    const targetOutput = prerenders.get(target) || output[target];
+    let targetFunction;
+    if (targetOutput?.type === "Prerender") {
+      targetFunction = targetOutput.lambda;
+    } else if (targetOutput?.type === "Lambda" || targetOutput?.type === "EdgeFunction") {
+      targetFunction = targetOutput;
+    }
+    if (!targetFunction) {
+      throw new Error(
+        `Could not find target "${target}" Lambda or EdgeFunction for path "${path}"`
+      );
+    }
+    const srcOutput = prerenders.get(path);
+    if (srcOutput) {
+      if (srcOutput.type === "Prerender") {
+        if (targetFunction.type === "Lambda") {
+          srcOutput.lambda = targetFunction;
+        } else {
+          throw new Error(
+            `Unexpected function type "${targetFunction.type}" at path "${path}"`
+          );
+        }
+      } else {
+        throw new Error(
+          `Unexpected output type "${srcOutput.type}" at path "${path}"`
+        );
+      }
+    } else {
+      output[path] = targetFunction;
+    }
+  }
+}
+function appendSortedPrerenders(output, prerenders) {
+  const sortedPrerenders = Array.from(prerenders.entries()).sort((a, b) => {
+    return (a[1].group ?? 0) - (b[1].group ?? 0);
+  }).reduce((o, [path, prerender]) => {
+    o[path] = prerender;
+    return o;
+  }, {});
+  Object.assign(output, sortedPrerenders);
+}
+function getBundleableLambdas(output) {
+  const bundleableLambdas = {};
+  for (const [outputName, curOutput] of Object.entries(output)) {
+    if (curOutput.type === "Lambda" && curOutput.experimentalAllowBundling) {
+      bundleableLambdas[outputName] = curOutput;
+    } else if (curOutput.type === "Prerender" && curOutput.lambda && curOutput.lambda.experimentalAllowBundling) {
+      bundleableLambdas[outputName] = curOutput.lambda;
+    }
+  }
+  return bundleableLambdas;
+}
+function applyGroupedLambdas(output, groupedLambdas) {
+  for (const outputName of Object.keys(groupedLambdas)) {
+    const groupedLambda = groupedLambdas[outputName];
+    const origOutput = output[outputName];
+    if (origOutput.type === "Lambda") {
+      output[outputName] = groupedLambda;
+    } else if (origOutput.type === "Prerender" && origOutput.lambda) {
+      origOutput.lambda = groupedLambda;
+    }
+  }
+}
+async function deserializeBuildOutput(options) {
+  const {
+    outputDir,
+    repoRootPath,
+    maxBundleSizeMb,
+    debugGroupLambdas,
+    useOnlyStreamingLambda,
+    forceNodejsStreaming,
+    deserializeLambda,
+    groupLambdas,
+    inspectSerializedLambda,
+    warn,
+    includeDeploymentId,
+    getMeta
+  } = options;
+  let hasServerActions = false;
+  const configPath = (0, import_path.join)(outputDir, "config.json");
+  const config = await (0, import_maybe_read_json.maybeReadJSON)(configPath);
+  if (!config) {
+    throw new Error(`Config file was not found at "${configPath}"`);
+  }
+  if (config.version !== 3) {
+    throw new Error(
+      `Expected \`version: 3\` in "${configPath}" file (received \`${config.version}\`)`
+    );
+  }
+  validateDeploymentId(config.deploymentId);
+  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,
+    follow: true
+  });
+  applyOutputOverrides(output, config.overrides, warn);
+  const fileFsRefsCache = /* @__PURE__ */ new Map();
+  const prerenders = /* @__PURE__ */ new Map();
+  const functionsDir = (0, import_path.join)(outputDir, "functions");
+  const functionSymlinks = /* @__PURE__ */ new Map();
+  for await (const path of (0, import_create_functions_iterator.createFunctionsIterator)(functionsDir)) {
+    let lambda = void 0;
+    const fnDir = (0, import_path.join)(functionsDir, `${path}.func`);
+    try {
+      const link = await fs.readlink(fnDir);
+      const target = (0, import_path.join)((0, import_path.dirname)(path), link).slice(0, -5);
+      functionSymlinks.set(path, target);
+    } catch (err) {
+      if (err.code !== "EINVAL")
+        throw err;
+      const funcConfigPath = (0, import_path.join)(fnDir, ".vc-config.json");
+      const funcConfig = await (0, import_maybe_read_json.maybeReadJSON)(
+        funcConfigPath
+      );
+      if (!funcConfig) {
+        throw new Error(`Could not load function config: "${funcConfigPath}"`);
+      }
+      const files = await (0, import_glob.default)("**", { cwd: fnDir, includeDirectories: true });
+      delete files[".vc-config.json"];
+      if (funcConfig.type === "EdgeFunction" || funcConfig.runtime === "edge") {
+        output[path] = await (0, import_deserialize_edge_function.deserializeEdgeFunction)(
+          files,
+          funcConfig,
+          repoRootPath,
+          fileFsRefsCache
+        );
+        continue;
+      }
+      lambda = await deserializeLambda(
+        files,
+        funcConfig,
+        repoRootPath,
+        fileFsRefsCache,
+        { useOnlyStreamingLambda, forceNodejsStreaming }
+      );
+      if (inspectSerializedLambda) {
+        hasServerActions = await inspectSerializedLambda(
+          path,
+          funcConfig,
+          repoRootPath,
+          hasServerActions
+        );
+      }
+    }
+    const prerenderConfigPath = (0, import_path.join)(
+      functionsDir,
+      `${path}.prerender-config.json`
+    );
+    const prerenderConfig = await (0, import_maybe_read_json.maybeReadJSON)(
+      prerenderConfigPath
+    );
+    if (prerenderConfig) {
+      const fallback = await deserializePrerenderFallback(
+        prerenderConfigPath,
+        prerenderConfig.fallback
+      );
+      const prerender = new import_prerender.Prerender({
+        ...prerenderConfig,
+        lambda,
+        fallback
+      });
+      prerenders.set(path, prerender);
+    } else if (lambda) {
+      output[path] = lambda;
+    }
+  }
+  applyFunctionSymlinks(output, prerenders, functionSymlinks);
+  appendSortedPrerenders(output, prerenders);
+  const groupedLambdas = await groupLambdas(
+    getBundleableLambdas(output),
+    {
+      force: void 0,
+      maxBundleSizeMb,
+      debug: debugGroupLambdas
+    }
+  );
+  applyGroupedLambdas(output, groupedLambdas);
+  const framework = (0, import_validate_framework_version.validateFrameworkVersion)(config?.framework?.version);
+  const meta = getMeta?.(hasServerActions);
+  return {
+    wildcard: config.wildcard,
+    images: config.images,
+    crons: config.crons,
+    flags: flags ? flags : config.flags,
+    routes: config.routes,
+    output,
+    framework,
+    ...includeDeploymentId ? { deploymentId: config.deploymentId } : {},
+    ...meta !== void 0 ? { meta } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeBuildOutput,
+  validateDeploymentId
+});

package/dist/file-blob.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { FileBase } from './types';
 interface FileBlobOptions {
     mode?: number;

package/dist/file-blob.js

@@ -56,7 +56,9 @@ class FileBlob {
         (chunk) => (
           // Usually the chunks we receive here are already buffers, so we
           // avoid the extra buffer copy in those cases to save memory
-          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+          chunks.push(
+            Uint8Array.from(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+          )
         )
       );
       stream.on("error", (error) => reject(error));

package/dist/file-fs-ref.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { FileBase } from './types';
 interface FileFsRefOptions {
     mode?: number;

package/dist/file-ref.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { FileBase } from './types';
 interface FileRefOptions {
     mode?: number;

package/dist/finalize-lambda.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { Lambda } from './lambda';
 import type { NodejsLambda } from './nodejs-lambda';
 import type { BytecodeCachingOptions } from './process-serverless/get-lambda-preload-scripts';

package/dist/fs/run-user-scripts.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { SpawnOptions } from 'child_process';
 import { Meta, PackageJson, NodeVersion, Config, BunVersion } from '../types';
 export type CliType = 'yarn' | 'npm' | 'pnpm' | 'bun' | 'vlt';

package/dist/fs/stream-to-buffer.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export default function streamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
 export declare function streamToBufferChunks(stream: NodeJS.ReadableStream, chunkSize?: number): Promise<Buffer[]>;

package/dist/fs/stream-to-buffer.js

@@ -36,7 +36,10 @@ var import_end_of_stream = __toESM(require("end-of-stream"));
 function streamToBuffer(stream) {
   return new Promise((resolve, reject) => {
     const buffers = [];
-    stream.on("data", buffers.push.bind(buffers));
+    stream.on("data", (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      buffers.push(Uint8Array.from(buffer));
+    });
     (0, import_end_of_stream.default)(stream, (err) => {
       if (err) {
         reject(err);
@@ -48,7 +51,7 @@ function streamToBuffer(stream) {
             resolve(Buffer.allocUnsafe(0));
             break;
           case 1:
-            resolve(buffers[0]);
+            resolve(Buffer.from(buffers[0]));
             break;
           default:
             resolve(Buffer.concat(buffers));
@@ -70,7 +73,9 @@ async function streamToBufferChunks(stream, chunkSize = 100 * MB) {
     while (offset < buffer.length) {
       const remainingSpace = chunkSize - currentSize;
       const sliceSize = Math.min(remainingSpace, buffer.length - offset);
-      currentChunk.push(buffer.slice(offset, offset + sliceSize));
+      currentChunk.push(
+        Uint8Array.from(buffer.subarray(offset, offset + sliceSize))
+      );
       currentSize += sliceSize;
       offset += sliceSize;
       if (currentSize >= chunkSize) {

package/dist/fs/stream-to-digest-async.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export interface FileDigest {
     md5: string;
     sha256: string;

package/dist/fs/stream-to-digest-async.js

@@ -41,8 +41,9 @@ async function streamToDigestAsync(stream) {
     stream.on("readable", () => {
       let chunk;
       while (null !== (chunk = stream.read())) {
-        md52.update(chunk);
-        sha2562.update(chunk);
+        const buffer = Buffer.isBuffer(chunk) ? Uint8Array.from(chunk) : Uint8Array.from(Buffer.from(chunk));
+        md52.update(buffer);
+        sha2562.update(buffer);
         count += chunk.length;
       }
     });
@@ -52,7 +53,7 @@ function sha256(value) {
   return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
 }
 function md5(value) {
-  return (0, import_crypto.createHash)("md5").update(value).digest("hex");
+  return (0, import_crypto.createHash)("md5").update(Uint8Array.from(value)).digest("hex");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.ts

@@ -57,6 +57,8 @@ export { validateFrameworkVersion } from './deserialize/validate-framework-versi
 export { hydrateFilesMap } from './deserialize/hydrate-files-map';
 export { createFunctionsIterator } from './deserialize/create-functions-iterator';
 export { maybeReadJSON } from './deserialize/maybe-read-json';
+export { deserializeBuildOutput, validateDeploymentId, } from './deserialize/deserialize-build-output';
+export type { DeserializeBuildOutputConfig, DeserializeBuildOutputResult, DeserializeBuildOutputPathOverride, DeserializeBuildOutputOptions, DeserializeBuildOutputLambdaOptions, GroupLambdasOptions, DeserializeBuildOutputSerializedConfig, DeserializeBuildOutputSerializedPrerender, } from './deserialize/deserialize-build-output-types';
 export { deserializeLambda, type DeserializeLambdaOptions, } from './deserialize/deserialize-lambda';
 export { deserializeEdgeFunction } from './deserialize/deserialize-edge-function';
 export type { Properties, SerializedLambda, SerializedNodejsLambda, SerializedEdgeFunction, SerializedFileFsRef, SerializedPrerender, } from './deserialize/serialized-types';