@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/lib/app/preview-build.js

@@ -1,7 +1,9 @@
-import { resolveBunEntrypoint } from "./bun-project.js";
-import { chmod, copyFile, cp, lstat, mkdir, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
+import { readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
+import { PRISMA_APP_CONFIG_FILENAME, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolvePreviewBuildSettings, runResolvedBuildCommand } from "./preview-build-settings.js";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
+import os from "node:os";
+import { AstroBuild, BunBuild, NuxtBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-build.ts
 const PREVIEW_BUILD_TYPES = [
 	"auto",
@@ -16,24 +18,32 @@ var PreviewBuildStrategy = class {
 	#appPath;
 	#entrypoint;
 	#buildType;
+	#signal;
+	#buildSettings;
 	constructor(options) {
 		this.#appPath = options.appPath;
 		this.#entrypoint = options.entrypoint;
 		this.#buildType = options.buildType ?? "auto";
+		this.#signal = options.signal;
+		this.#buildSettings = options.buildSettings;
 	}
-	async canBuild() {
+	async canBuild(signal = this.#signal) {
 		const { strategy } = await resolvePreviewBuildStrategy({
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
-			buildType: this.#buildType
+			buildType: this.#buildType,
+			signal,
+			buildSettings: this.#buildSettings
 		});
-		return strategy.canBuild();
+		return strategy.canBuild(signal);
 	}
-	async execute() {
+	async execute(signal = this.#signal) {
 		const { artifact } = await executePreviewBuild({
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
-			buildType: this.#buildType
+			buildType: this.#buildType,
+			signal,
+			buildSettings: this.#buildSettings
 		});
 		return artifact;
 	}
@@ -42,12 +52,13 @@ async function executePreviewBuild(options) {
 	const { strategy, buildType } = await resolvePreviewBuildStrategy({
 		appPath: options.appPath,
 		entrypoint: options.entrypoint,
-		buildType: options.buildType ?? "auto"
+		buildType: options.buildType ?? "auto",
+		signal: options.signal,
+		buildSettings: options.buildSettings
 	});
-	const artifact = await strategy.execute();
+	const artifact = await strategy.execute(options.signal);
 	try {
-		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath);
-		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath, options.signal);
 		return {
 			artifact,
 			buildType
@@ -62,7 +73,9 @@ async function resolvePreviewBuildStrategy(options) {
 		const strategy = await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType: options.buildType
+			buildType: options.buildType,
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		});
 		return {
 			buildType: options.buildType,
@@ -74,9 +87,11 @@ async function resolvePreviewBuildStrategy(options) {
 		const strategy = await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType
+			buildType,
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		});
-		if (await strategy.canBuild()) return {
+		if (await strategy.canBuild(options.signal)) return {
 			buildType,
 			strategy
 		};
@@ -86,25 +101,171 @@ async function resolvePreviewBuildStrategy(options) {
 		strategy: await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType: "bun"
+			buildType: "bun",
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		})
 	};
 }
 async function createPreviewBuildStrategy(options) {
 	switch (options.buildType) {
-		case "nextjs": return new NextjsBuild({ appPath: options.appPath });
+		case "nextjs": return new PreviewNextjsBuild({
+			appPath: options.appPath,
+			buildSettings: options.buildSettings
+		});
 		case "nuxt": return new NuxtBuild({ appPath: options.appPath });
 		case "astro": return new AstroBuild({ appPath: options.appPath });
-		case "tanstack-start": return new TanstackStartBuild({ appPath: options.appPath });
+		case "tanstack-start": return new PreviewTanstackStartBuild({
+			appPath: options.appPath,
+			buildSettings: options.buildSettings
+		});
 		case "bun": {
-			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
-			return new BunBuild({
+			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
+			return new PreviewBunBuild({
 				appPath: options.appPath,
-				entrypoint
+				strategy: new BunBuild({
+					appPath: options.appPath,
+					entrypoint
+				}),
+				buildSettings: options.buildSettings
 			});
 		}
 	}
 }
+var PreviewNextjsBuild = class {
+	#appPath;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		const packageJson = await readBunPackageJson(this.#appPath, signal);
+		return await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES, signal) || hasPackageDependency(packageJson, "next");
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "nextjs",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "Next.js", signal);
+		const standaloneDir = path.join(this.#appPath, settings.outputDirectory);
+		if (!await directoryExists(standaloneDir, signal)) throw new Error(`Next.js build did not produce standalone output at ${settings.outputDirectory}. Add output: "standalone" to your next.config file, or update ${PRISMA_APP_CONFIG_FILENAME}.`);
+		const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await stageNextjsStandaloneArtifact({
+				standaloneDir,
+				artifactDir,
+				appPath: this.#appPath,
+				signal
+			});
+			const entrypoint = await findNextStandaloneEntrypoint(artifactDir, signal);
+			await copyNextjsStaticAssets({
+				appPath: this.#appPath,
+				artifactDir,
+				outputRoot: nextOutputRootFromStandaloneDirectory(settings.outputDirectory),
+				entrypoint,
+				signal
+			});
+			return {
+				directory: artifactDir,
+				entrypoint,
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+};
+var PreviewTanstackStartBuild = class {
+	#appPath;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		return hasAnyPackageDependency(await readBunPackageJson(this.#appPath, signal), TANSTACK_START_PACKAGES);
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "tanstack-start",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "TanStack Start", signal);
+		const outputDir = path.join(this.#appPath, settings.outputDirectory);
+		const entrypoint = "server/index.mjs";
+		const entryPath = path.join(outputDir, entrypoint);
+		if (!(await unsupportedFilesystemBoundary(signal, () => stat(entryPath).catch(() => null)))?.isFile()) throw new Error(`TanStack Start build did not produce a Nitro node server entrypoint at ${joinPosix(settings.outputDirectory, entrypoint)}. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset, or update ${PRISMA_APP_CONFIG_FILENAME}.`);
+		const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await unsupportedFilesystemBoundary(signal, () => cp(outputDir, artifactDir, {
+				recursive: true,
+				verbatimSymlinks: true
+			}));
+			return {
+				directory: artifactDir,
+				entrypoint,
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+};
+var PreviewBunBuild = class {
+	#appPath;
+	#strategy;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#strategy = options.strategy;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		return this.#strategy.canBuild(signal);
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "bun",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "Bun", signal);
+		return this.#strategy.execute(signal);
+	}
+};
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+const TANSTACK_START_PACKAGES = [
+	"@tanstack/react-start",
+	"@tanstack/solid-start",
+	"@tanstack/start"
+];
 async function stageNextjsStandaloneArtifact(options) {
 	const standaloneRoot = path.resolve(options.standaloneDir);
 	const artifactRoot = path.resolve(options.artifactDir);
@@ -112,74 +273,88 @@ async function stageNextjsStandaloneArtifact(options) {
 	await copyPathMaterializingSymlinks(standaloneRoot, artifactRoot, {
 		standaloneRoot,
 		appRoot,
-		sourceRoot: await resolveSourceRoot(appRoot)
+		sourceRoot: await resolveSourceRoot(appRoot, options.signal),
+		signal: options.signal
 	});
-	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"));
+	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"), options.signal);
 }
-async function restageNextjsArtifact(artifact, appPath) {
-	const artifactDir = artifact.directory;
-	const standaloneDir = path.join(appPath, ".next", "standalone");
-	await rm(artifactDir, {
-		recursive: true,
-		force: true
-	});
-	await stageNextjsStandaloneArtifact({
-		standaloneDir,
-		artifactDir,
-		appPath
-	});
-	const serverSubpath = nextjsServerSubpath(artifact.entrypoint);
-	const serverDir = serverSubpath ? path.join(artifactDir, serverSubpath) : artifactDir;
-	const publicDir = path.join(appPath, "public");
-	if (await directoryExists(publicDir)) await cp(publicDir, path.join(serverDir, "public"), {
+async function copyNextjsStaticAssets(options) {
+	const serverSubpath = nextjsServerSubpath(options.entrypoint);
+	const serverDir = serverSubpath ? path.join(options.artifactDir, serverSubpath) : options.artifactDir;
+	const publicDir = path.join(options.appPath, "public");
+	if (await directoryExists(publicDir, options.signal)) await unsupportedFilesystemBoundary(options.signal, () => cp(publicDir, path.join(serverDir, "public"), {
 		recursive: true,
 		verbatimSymlinks: true
-	});
-	const staticDir = path.join(appPath, ".next", "static");
-	if (await directoryExists(staticDir)) await cp(staticDir, path.join(serverDir, ".next", "static"), {
+	}));
+	const staticDir = path.join(options.appPath, options.outputRoot, "static");
+	if (await directoryExists(staticDir, options.signal)) await unsupportedFilesystemBoundary(options.signal, () => cp(staticDir, path.join(serverDir, options.outputRoot, "static"), {
 		recursive: true,
 		verbatimSymlinks: true
-	});
+	}));
+}
+async function findNextStandaloneEntrypoint(artifactDir, signal) {
+	const rootEntrypoint = path.join(artifactDir, "server.js");
+	if ((await unsupportedFilesystemBoundary(signal, () => stat(rootEntrypoint).catch(() => null)))?.isFile()) return "server.js";
+	const candidates = [];
+	await walk(artifactDir);
+	candidates.sort((left, right) => left.split("/").length - right.split("/").length || left.localeCompare(right));
+	const selected = candidates[0];
+	if (!selected) throw new Error(`Next.js standalone output did not contain server.js in ${artifactDir}`);
+	return selected;
+	async function walk(directory) {
+		const entries = await unsupportedFilesystemBoundary(signal, () => readdir(directory, { withFileTypes: true }));
+		for (const entry of entries) {
+			if (entry.name === "node_modules") continue;
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await walk(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name === "server.js") candidates.push(path.relative(artifactDir, fullPath).split(path.sep).join("/"));
+		}
+	}
 }
 function nextjsServerSubpath(entrypoint) {
 	const dir = path.posix.dirname(entrypoint);
 	return dir === "." ? "" : dir;
 }
-async function hoistPnpmDependencies(nodeModulesDir) {
+async function hoistPnpmDependencies(nodeModulesDir, signal) {
 	const pnpmNodeModulesDir = path.join(nodeModulesDir, ".pnpm", "node_modules");
-	if (!await directoryExists(pnpmNodeModulesDir)) return;
-	const entries = await readdir(pnpmNodeModulesDir, { withFileTypes: true });
+	if (!await directoryExists(pnpmNodeModulesDir, signal)) return;
+	const entries = await unsupportedFilesystemBoundary(signal, () => readdir(pnpmNodeModulesDir, { withFileTypes: true }));
 	for (const entry of entries) {
 		const sourcePath = path.join(pnpmNodeModulesDir, entry.name);
 		if (entry.name.startsWith("@") && entry.isDirectory()) {
-			const scopedEntries = await readdir(sourcePath, { withFileTypes: true });
+			const scopedEntries = await unsupportedFilesystemBoundary(signal, () => readdir(sourcePath, { withFileTypes: true }));
 			for (const scopedEntry of scopedEntries) {
 				const scopedDestination = path.join(nodeModulesDir, entry.name, scopedEntry.name);
-				if (await pathExists(scopedDestination)) continue;
-				await mkdir(path.dirname(scopedDestination), { recursive: true });
+				if (await pathExists(scopedDestination, signal)) continue;
+				await unsupportedFilesystemBoundary(signal, () => mkdir(path.dirname(scopedDestination), { recursive: true }));
 				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
 					standaloneRoot: pnpmNodeModulesDir,
 					appRoot: nodeModulesDir,
-					sourceRoot: nodeModulesDir
+					sourceRoot: nodeModulesDir,
+					signal
 				});
 			}
 			continue;
 		}
 		const destinationPath = path.join(nodeModulesDir, entry.name);
-		if (await pathExists(destinationPath)) continue;
+		if (await pathExists(destinationPath, signal)) continue;
 		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
 			standaloneRoot: pnpmNodeModulesDir,
 			appRoot: nodeModulesDir,
-			sourceRoot: nodeModulesDir
+			sourceRoot: nodeModulesDir,
+			signal
 		});
 	}
 }
-async function normalizeArtifactSymlinks(artifactDir, appPath) {
+async function normalizeArtifactSymlinks(artifactDir, appPath, signal) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
 	await walkDirectory(normalizedArtifactDir);
 	async function walkDirectory(directory) {
-		const entries = await readdir(directory, { withFileTypes: true });
+		const entries = await unsupportedFilesystemBoundary(signal, () => readdir(directory, { withFileTypes: true }));
 		for (const entry of entries) {
 			const fullPath = path.join(directory, entry.name);
 			if (entry.isDirectory()) {
@@ -187,19 +362,19 @@ async function normalizeArtifactSymlinks(artifactDir, appPath) {
 				continue;
 			}
 			if (!entry.isSymbolicLink()) continue;
-			const target = await readlink(fullPath);
+			const target = await unsupportedFilesystemBoundary(signal, () => readlink(fullPath));
 			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
 			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
 			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
-			const targetStat = await stat(resolvedTarget);
-			await rm(fullPath, {
+			const targetStat = await unsupportedFilesystemBoundary(signal, () => stat(resolvedTarget));
+			await unsupportedFilesystemBoundary(signal, () => rm(fullPath, {
 				force: true,
 				recursive: true
-			});
-			await cp(resolvedTarget, fullPath, {
+			}));
+			await unsupportedFilesystemBoundary(signal, () => cp(resolvedTarget, fullPath, {
 				recursive: targetStat.isDirectory(),
 				dereference: true
-			});
+			}));
 			if (targetStat.isDirectory()) await walkDirectory(fullPath);
 		}
 	}
@@ -208,8 +383,11 @@ function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
 }
+function isPathWithinWorkspaceDependency(sourceRoot, candidatePath) {
+	return isPathWithin(path.join(sourceRoot, "node_modules"), candidatePath);
+}
 async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
-	const sourceStat = await lstat(sourcePath);
+	const sourceStat = await unsupportedFilesystemBoundary(options.signal, () => lstat(sourcePath));
 	if (sourceStat.isSymbolicLink()) {
 		const resolvedTarget = await resolveSymlinkTarget(sourcePath, options);
 		if (resolvedTarget === null) return;
@@ -217,27 +395,27 @@ async function copyPathMaterializingSymlinks(sourcePath, destinationPath, option
 		return;
 	}
 	if (sourceStat.isDirectory()) {
-		await mkdir(destinationPath, { recursive: true });
-		const entries = await readdir(sourcePath, { withFileTypes: true });
+		await unsupportedFilesystemBoundary(options.signal, () => mkdir(destinationPath, { recursive: true }));
+		const entries = await unsupportedFilesystemBoundary(options.signal, () => readdir(sourcePath, { withFileTypes: true }));
 		for (const entry of entries) await copyPathMaterializingSymlinks(path.join(sourcePath, entry.name), path.join(destinationPath, entry.name), options);
 		return;
 	}
 	if (sourceStat.isFile()) {
-		await mkdir(path.dirname(destinationPath), { recursive: true });
-		await copyFile(sourcePath, destinationPath);
-		await chmod(destinationPath, sourceStat.mode);
+		await unsupportedFilesystemBoundary(options.signal, () => mkdir(path.dirname(destinationPath), { recursive: true }));
+		await unsupportedFilesystemBoundary(options.signal, () => copyFile(sourcePath, destinationPath));
+		await unsupportedFilesystemBoundary(options.signal, () => chmod(destinationPath, sourceStat.mode));
 	}
 }
 async function resolveSymlinkTarget(symlinkPath, options) {
-	const linkTarget = await readlink(symlinkPath);
+	const linkTarget = await unsupportedFilesystemBoundary(options.signal, () => readlink(symlinkPath));
 	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
-	if (await pathExists(resolvedTarget)) {
-		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithin(options.sourceRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+	if (await pathExists(resolvedTarget, options.signal)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithinWorkspaceDependency(options.sourceRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
 		return resolvedTarget;
 	}
 	if (isPathWithin(options.standaloneRoot, resolvedTarget)) {
 		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
-		if (await pathExists(fallbackTarget)) return fallbackTarget;
+		if (await pathExists(fallbackTarget, options.signal)) return fallbackTarget;
 	}
 	if (isPnpmHoistLink(symlinkPath)) return null;
 	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
@@ -247,38 +425,51 @@ function isPnpmHoistLink(symlinkPath) {
 	for (let i = 0; i < parts.length - 1; i++) if (parts[i] === ".pnpm" && parts[i + 1] === "node_modules") return true;
 	return false;
 }
-async function pathExists(targetPath) {
+async function pathExists(targetPath, signal) {
 	try {
-		await stat(targetPath);
+		await unsupportedFilesystemBoundary(signal, () => stat(targetPath));
 		return true;
-	} catch {
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
-async function directoryExists(targetPath) {
+async function directoryExists(targetPath, signal) {
 	try {
-		return (await stat(targetPath)).isDirectory();
-	} catch {
+		return (await unsupportedFilesystemBoundary(signal, () => stat(targetPath))).isDirectory();
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
-async function resolveSourceRoot(appRoot) {
+async function resolveSourceRoot(appRoot, signal) {
 	let current = path.resolve(appRoot);
 	while (true) {
-		if (await pathExists(path.join(current, ".git")) || await pathExists(path.join(current, "pnpm-workspace.yaml")) || await pathExists(path.join(current, "bun.lock")) || await pathExists(path.join(current, "bun.lockb")) || await packageJsonDeclaresWorkspaces(current)) return current;
+		if (await pathExists(path.join(current, ".git"), signal) || await pathExists(path.join(current, "pnpm-workspace.yaml"), signal) || await pathExists(path.join(current, "bun.lock"), signal) || await pathExists(path.join(current, "bun.lockb"), signal) || await packageJsonDeclaresWorkspaces(current, signal)) return current;
 		const parent = path.dirname(current);
 		if (parent === current) return path.resolve(appRoot);
 		current = parent;
 	}
 }
-async function packageJsonDeclaresWorkspaces(directory) {
+async function packageJsonDeclaresWorkspaces(directory, signal) {
+	signal?.throwIfAborted();
 	try {
-		const content = await readFile(path.join(directory, "package.json"), "utf8");
+		const content = await readFile(path.join(directory, "package.json"), {
+			encoding: "utf8",
+			signal
+		});
 		const parsed = JSON.parse(content);
 		return Boolean(parsed.workspaces);
-	} catch {
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
+async function unsupportedFilesystemBoundary(signal, operation) {
+	signal?.throwIfAborted();
+	const result = await operation();
+	signal?.throwIfAborted();
+	return result;
+}
 //#endregion
 export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };