devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/_chunks/build-artifacts-BNssqhxE.js

@@ -0,0 +1,483 @@
+import { d as resolveConfigEnvVars } from "./preview-C3Cdr8an.js";
+import { r as loadConfig, u as resolveConfigForEnvironment } from "./loader-OQ2AWpqm.js";
+import { c as writeWranglerConfig, i as isolateViteBuildOutputPaths$1, o as rebaseWranglerConfigPaths, t as compileBuildConfig } from "./compiler-BtLp9T9N.js";
+import { f as logLine } from "./ui-BUoZApvE.js";
+import { n as getPackageVersion } from "./package-metadata-DjHBLB-z.js";
+import { t as resolvePackageSpecifier } from "./resolve-package-qizBfCIm.js";
+import { i as writeGeneratedViteConfig, l as prepareComposedWorkerEntrypoint, n as resolveEffectiveViteProject } from "./vite-D_wLDGBs.js";
+import { t as bundleWorkerEntry } from "./worker-bundler-dTTnYU3n.js";
+import { t as detectViteProject } from "./vite-utils-OVLMV605.js";
+import { t as getDependencies } from "./dependencies-C2oxFjU_.js";
+import { n as getGeneratedArtifactPaths, t as ensureGeneratedDirectory } from "./generated-artifacts-dMJY4KAt.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "pathe";
+import { createHash } from "node:crypto";
+const BUILD_MANIFEST_FILENAME = "manifest.json";
+/**
+* Compute a stable hash of the source DevflareConfig. Used both at build
+* time (to stamp the manifest) and at deploy time (to detect drift).
+*
+* The hash deliberately ignores transient fields like `accountId` so that
+* setting CLOUDFLARE_ACCOUNT_ID between build and deploy doesn't trip drift.
+*/
+function hashSourceConfig(config) {
+	const normalized = JSON.stringify(config, (key, value) => {
+		if (key === "accountId") return void 0;
+		if (value === null || value === void 0) return void 0;
+		if (key === "__ref" && value && typeof value === "object") {
+			const nameOverride = value.__nameOverride;
+			return nameOverride ? `ref:${nameOverride}` : "ref:<unresolved>";
+		}
+		return value;
+	});
+	return createHash("sha256").update(normalized).digest("hex");
+}
+function summarizeBindings(config) {
+	const bindings = config.bindings ?? {};
+	return {
+		kv: Object.keys(bindings.kv ?? {}).sort(),
+		d1: Object.keys(bindings.d1 ?? {}).sort(),
+		r2: Object.keys(bindings.r2 ?? {}).sort(),
+		queues: Object.keys(bindings.queues ?? {}).sort(),
+		rateLimits: Object.keys(bindings.rateLimits ?? {}).sort(),
+		versionMetadata: bindings.versionMetadata ? [bindings.versionMetadata.binding] : [],
+		workerLoaders: Object.keys(bindings.workerLoaders ?? {}).sort(),
+		mtlsCertificates: Object.keys(bindings.mtlsCertificates ?? {}).sort(),
+		dispatchNamespaces: Object.keys(bindings.dispatchNamespaces ?? {}).sort(),
+		workflows: Object.keys(bindings.workflows ?? {}).sort(),
+		pipelines: Object.keys(bindings.pipelines ?? {}).sort(),
+		images: Object.keys(bindings.images ?? {}).sort(),
+		media: Object.keys(bindings.media ?? {}).sort(),
+		artifacts: Object.keys(bindings.artifacts ?? {}).sort(),
+		secretsStore: Object.keys(bindings.secretsStore ?? {}).sort(),
+		tailConsumers: (config.tailConsumers ?? []).map((consumer) => typeof consumer === "string" ? consumer : consumer.service).sort(),
+		hyperdrive: Object.keys(bindings.hyperdrive ?? {}).sort(),
+		vectorize: Object.keys(bindings.vectorize ?? {}).sort(),
+		services: Object.keys(bindings.services ?? {}).sort()
+	};
+}
+function createBuildManifest(config, options) {
+	return {
+		manifestVersion: 1,
+		devflareVersion: options.devflareVersion,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		sourceConfigHash: hashSourceConfig(config),
+		intendedTarget: options.intendedTarget,
+		bindingsSnapshot: summarizeBindings(config)
+	};
+}
+async function writeBuildManifest(buildDir, manifest) {
+	const manifestPath = resolve(buildDir, BUILD_MANIFEST_FILENAME);
+	await writeFile(manifestPath, `${JSON.stringify(manifest, null, "	")}\n`, "utf-8");
+	return manifestPath;
+}
+async function readBuildManifest(buildDir) {
+	const manifestPath = resolve(buildDir, BUILD_MANIFEST_FILENAME);
+	try {
+		const raw = await readFile(manifestPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed?.manifestVersion !== "number") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function targetsEqual(a, b) {
+	return a.environment === b.environment && a.preview === b.preview && a.previewScope === b.previewScope && a.branchName === b.branchName;
+}
+function compareManifests(previous, current) {
+	const prevBindings = new Set(Object.entries(previous.bindingsSnapshot).flatMap(([k, v]) => v.map((n) => `${k}:${n}`)));
+	const currBindings = new Set(Object.entries(current.bindingsSnapshot).flatMap(([k, v]) => v.map((n) => `${k}:${n}`)));
+	const bindingsAdded = [...currBindings].filter((b) => !prevBindings.has(b));
+	const bindingsRemoved = [...prevBindings].filter((b) => !currBindings.has(b));
+	return {
+		configChanged: previous.sourceConfigHash !== current.sourceConfigHash,
+		versionChanged: previous.devflareVersion !== current.devflareVersion,
+		targetChanged: !targetsEqual(previous.intendedTarget, current.intendedTarget),
+		previousVersion: previous.devflareVersion,
+		currentVersion: current.devflareVersion,
+		previousTarget: previous.intendedTarget,
+		currentTarget: current.intendedTarget,
+		bindingsAdded,
+		bindingsRemoved
+	};
+}
+function formatDriftWarning(drift) {
+	const lines = [];
+	if (drift.versionChanged) lines.push(`devflare version differs (built with ${drift.previousVersion}, deploying with ${drift.currentVersion})`);
+	if (drift.targetChanged) lines.push(`deployment target differs (built for ${formatTarget(drift.previousTarget)}, deploying as ${formatTarget(drift.currentTarget)})`);
+	if (drift.configChanged) lines.push("source config changed since build (devflare.config.ts hash differs)");
+	if (drift.bindingsAdded.length > 0) lines.push(`bindings added since build: ${drift.bindingsAdded.join(", ")}`);
+	if (drift.bindingsRemoved.length > 0) lines.push(`bindings removed since build: ${drift.bindingsRemoved.join(", ")}`);
+	if (lines.length === 0) return null;
+	return [
+		"Build artefact drift detected:",
+		...lines.map((line) => `  - ${line}`),
+		"Re-run `devflare build` to refresh the artefact, or pass --force to deploy anyway."
+	].join("\n");
+}
+function formatTarget(t) {
+	const parts = [];
+	if (t.environment) parts.push(`env=${t.environment}`);
+	parts.push(t.preview ? "preview" : "production");
+	if (t.previewScope) parts.push(`scope=${t.previewScope}`);
+	if (t.branchName) parts.push(`branch=${t.branchName}`);
+	return parts.join(" ");
+}
+//#endregion
+//#region src/cli/deploy-strategy.ts
+function normalizeBranchScope(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function shouldIncludePreviewCrons(config) {
+	return config.previews?.includeCrons === true;
+}
+function omitQueueConsumers(config) {
+	if (!config.bindings?.queues?.consumers?.length) return config;
+	const nextBindings = { ...config.bindings };
+	const nextQueues = { ...nextBindings.queues };
+	delete nextQueues.consumers;
+	if (!nextQueues.producers || Object.keys(nextQueues.producers).length === 0) delete nextBindings.queues;
+	else nextBindings.queues = nextQueues;
+	return {
+		...config,
+		bindings: nextBindings
+	};
+}
+function omitCronTriggers(config) {
+	if (!config.triggers?.crons?.length) return config;
+	const nextTriggers = { ...config.triggers };
+	delete nextTriggers.crons;
+	if (Object.keys(nextTriggers).length === 0) {
+		const { triggers: _triggers, ...rest } = config;
+		return rest;
+	}
+	return {
+		...config,
+		triggers: nextTriggers
+	};
+}
+function applyDeploymentStrategy(config, options = {}) {
+	const branchScope = normalizeBranchScope(options.previewBranch) ?? normalizeBranchScope(options.branchName);
+	if (!(!options.preview && options.environment === "preview" && Boolean(branchScope))) return {
+		config,
+		strategy: "default",
+		omittedResources: []
+	};
+	const omittedResources = [];
+	let nextConfig = config;
+	if (nextConfig.bindings?.queues?.consumers?.length) {
+		nextConfig = omitQueueConsumers(nextConfig);
+		omittedResources.push("queue-consumers");
+	}
+	if (!shouldIncludePreviewCrons(nextConfig) && nextConfig.triggers?.crons?.length) {
+		nextConfig = omitCronTriggers(nextConfig);
+		omittedResources.push("cron-triggers");
+	}
+	return {
+		config: nextConfig,
+		strategy: "preview-scope",
+		branchScope,
+		omittedResources
+	};
+}
+function describeDeploymentStrategy(result) {
+	if (result.strategy !== "preview-scope" || result.omittedResources.length === 0) return;
+	const labels = result.omittedResources.map((resource) => {
+		return resource === "queue-consumers" ? "queue consumers" : "cron triggers";
+	});
+	const formattedLabels = labels.length === 2 ? `${labels[0]} and ${labels[1]}` : labels[0];
+	return `Named preview-scope deploy detected${result.branchScope ? ` (${result.branchScope})` : ""}; omitting shared ${formattedLabels} from the deployed Wrangler config to avoid singleton Cloudflare resource conflicts.`;
+}
+//#endregion
+//#region src/cli/commands/build-artifacts.ts
+function getBuildArtifactPaths(cwd) {
+	return getGeneratedArtifactPaths(cwd);
+}
+function isNestedPath(parentPath, candidatePath) {
+	const normalizedParentPath = parentPath.replace(/\\/g, "/");
+	return candidatePath.replace(/\\/g, "/").startsWith(`${normalizedParentPath}/`);
+}
+function isolateViteBuildOutputPaths(cwd, wranglerConfig) {
+	return isolateViteBuildOutputPaths$1(cwd, wranglerConfig);
+}
+function getViteBuildCleanupTargets(cwd, wranglerConfig) {
+	const targets = [];
+	const assetsDirectory = wranglerConfig.assets?.directory;
+	const mainEntry = wranglerConfig.main;
+	if (assetsDirectory) targets.push(resolve(cwd, assetsDirectory));
+	if (mainEntry) {
+		const mainEntryPath = resolve(cwd, mainEntry);
+		if (!targets.some((targetPath) => {
+			return mainEntryPath === targetPath || isNestedPath(targetPath, mainEntryPath);
+		})) targets.push(mainEntryPath);
+	}
+	return targets;
+}
+function shouldRetryCleanup(error) {
+	if (!error || typeof error !== "object") return false;
+	const errorCode = error.code;
+	return errorCode === "EBUSY" || errorCode === "EPERM" || errorCode === "ENOTEMPTY";
+}
+async function getCleanupFileSystem() {
+	return await import("node:fs/promises");
+}
+async function pathExists(cleanupFs, targetPath) {
+	try {
+		await cleanupFs.access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function createDeferredCleanupPath(targetPath, uniqueSuffix) {
+	return `${targetPath}.devflare-stale-${uniqueSuffix ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`}`;
+}
+async function tryMoveLockedPathAside(targetPath, logger, cleanupFs) {
+	if (!await pathExists(cleanupFs, targetPath)) return true;
+	const deferredCleanupPath = createDeferredCleanupPath(targetPath);
+	try {
+		await cleanupFs.rename(targetPath, deferredCleanupPath);
+	} catch {
+		return false;
+	}
+	logger.warn(`Moved locked build output aside to ${deferredCleanupPath} after repeated cleanup failures; continuing build`);
+	try {
+		await cleanupFs.rm(deferredCleanupPath, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		const cleanupErrorCode = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "an unknown error";
+		logger.warn(`Deferred cleanup for ${deferredCleanupPath} is still blocked by ${cleanupErrorCode}; you can remove it manually later`);
+	}
+	return true;
+}
+async function removePathWithRetries(targetPath, logger, attempts = 5, cleanupFs) {
+	const fs = cleanupFs ?? await getCleanupFileSystem();
+	let lastError;
+	for (let attempt = 1; attempt <= attempts; attempt++) try {
+		await fs.rm(targetPath, {
+			recursive: true,
+			force: true
+		});
+		return;
+	} catch (error) {
+		lastError = error;
+		if (!shouldRetryCleanup(error) || attempt === attempts) break;
+		logger.warn(`Retrying cleanup for ${targetPath} after ${error.code} (${attempt}/${attempts})`);
+		await new Promise((resolveRetry) => setTimeout(resolveRetry, attempt * 100));
+	}
+	if (shouldRetryCleanup(lastError) && await tryMoveLockedPathAside(targetPath, logger, fs)) return;
+	if (shouldRetryCleanup(lastError)) {
+		const cleanupErrorCode = lastError instanceof Error && "code" in lastError && typeof lastError.code === "string" ? lastError.code : "an unknown error";
+		logger.warn(`Continuing build without pre-clean for ${targetPath} because cleanup is still blocked by ${cleanupErrorCode}`);
+		return;
+	}
+	throw lastError;
+}
+async function cleanupViteBuildOutputs(cwd, wranglerConfig, logger) {
+	const cleanupTargets = getViteBuildCleanupTargets(cwd, wranglerConfig);
+	for (const cleanupTarget of cleanupTargets) await removePathWithRetries(cleanupTarget, logger);
+}
+async function writeDeployRedirect(cwd, generatedConfigPath) {
+	const fs = await import("node:fs/promises");
+	const paths = getBuildArtifactPaths(cwd);
+	await ensureGeneratedDirectory(paths.deployDir);
+	const configPath = relative(paths.deployDir, generatedConfigPath).replace(/\\/g, "/");
+	await fs.writeFile(paths.deployRedirectPath, `${JSON.stringify({ configPath }, null, "	")}\n`, "utf-8");
+}
+async function readDeployRedirect(cwd) {
+	const fs = await import("node:fs/promises");
+	const paths = getBuildArtifactPaths(cwd);
+	try {
+		const rawConfig = await fs.readFile(paths.deployRedirectPath, "utf-8");
+		const parsed = JSON.parse(rawConfig);
+		if (typeof parsed.configPath !== "string" || parsed.configPath.length === 0) return null;
+		return resolve(dirname(paths.deployRedirectPath), parsed.configPath);
+	} catch {
+		return null;
+	}
+}
+async function writeGeneratedDeployWranglerConfig(cwd, wranglerConfig, options = {}) {
+	const paths = getBuildArtifactPaths(cwd);
+	await ensureGeneratedDirectory(paths.buildDir, true);
+	const buildConfig = rebaseWranglerConfigPaths(cwd, paths.buildDir, wranglerConfig);
+	if (options.main) buildConfig.main = options.main;
+	await writeWranglerConfig(paths.buildDir, buildConfig, "wrangler.jsonc");
+	return paths.buildWranglerConfigPath;
+}
+async function writeGeneratedDevWranglerConfig(cwd, wranglerConfig) {
+	const paths = getGeneratedArtifactPaths(cwd);
+	await ensureGeneratedDirectory(paths.devflareDir, true);
+	const devConfig = rebaseWranglerConfigPaths(cwd, paths.devflareDir, wranglerConfig);
+	await writeWranglerConfig(paths.devflareDir, devConfig, "wrangler.jsonc");
+	return paths.devWranglerConfigPath;
+}
+async function buildWorkerOnlyDeployArtifact(cwd, wranglerConfig, config, logger) {
+	if (!wranglerConfig.main) return await writeGeneratedDeployWranglerConfig(cwd, wranglerConfig);
+	const paths = getBuildArtifactPaths(cwd);
+	logLine(logger, `Generated deploy artifact: ${relative(cwd, await bundleWorkerEntry({
+		cwd,
+		inputFile: resolve(cwd, wranglerConfig.main),
+		outFile: paths.buildWorkerPath,
+		rolldownOptions: config.rolldown?.options,
+		sourcemap: config.rolldown?.sourcemap,
+		minify: config.rolldown?.minify,
+		logger
+	})).replace(/\\/g, "/")}`);
+	return await writeGeneratedDeployWranglerConfig(cwd, wranglerConfig, { main: "./worker.js" });
+}
+async function resolveLocalViteExecutable(cwd, fs) {
+	const workspaceLocal = await findWorkspaceLocalBinary(cwd, fs, [
+		"vite",
+		"bin",
+		"vite.js"
+	]);
+	if (workspaceLocal) return workspaceLocal;
+	const viteExecutablePath = resolvePackageSpecifier("vite/bin/vite.js", cwd);
+	try {
+		await fs.access(viteExecutablePath);
+	} catch {
+		throw new Error(`Could not resolve a local Vite CLI entrypoint from ${cwd}. Install vite in this package before running a Vite-backed Devflare build.`);
+	}
+	return viteExecutablePath;
+}
+/**
+* Walk up the directory tree from `startDir` looking for
+* `node_modules/<segments>`. Returns the first match or null.
+*
+* This preserves the workspace-local (symlinked) path rather than the
+* package manager's underlying cache realpath, which matters for Node
+* package resolution semantics under Bun on Windows.
+*/
+async function findWorkspaceLocalBinary(startDir, fs, segments) {
+	let currentDir = resolve(startDir);
+	for (let depth = 0; depth < 64; depth++) {
+		const candidate = resolve(currentDir, "node_modules", ...segments);
+		try {
+			await fs.access(candidate);
+			return candidate;
+		} catch {}
+		const parent = dirname(currentDir);
+		if (parent === currentDir) return null;
+		currentDir = parent;
+	}
+	return null;
+}
+/** True when the current process is Bun (and `bun` is therefore on PATH). */
+function isRunningUnderBun() {
+	return typeof globalThis.Bun !== "undefined" || typeof process.versions.bun === "string";
+}
+async function prepareBuildArtifacts(parsed, logger, options) {
+	const cwd = options.cwd || process.cwd();
+	const configPath = parsed.options.config;
+	const environment = parsed.options.env;
+	const config = await resolveConfigEnvVars(resolveConfigForEnvironment(await loadConfig({
+		cwd,
+		configFile: configPath
+	}), environment), {
+		cwd,
+		configPath,
+		mode: "build"
+	});
+	logLine(logger, `Building: ${config.name}`);
+	const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, config, environment);
+	const deps = await getDependencies();
+	const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd, deps.fs), config, environment);
+	const deploymentStrategy = applyDeploymentStrategy(config, {
+		environment,
+		preview: parsed.options.preview === true,
+		branchName: parsed.options["branch-name"],
+		previewBranch: process.env.DEVFLARE_PREVIEW_BRANCH
+	});
+	const deploymentStrategyMessage = describeDeploymentStrategy(deploymentStrategy);
+	if (deploymentStrategyMessage) logLine(logger, deploymentStrategyMessage);
+	const devWranglerConfig = viteProject.shouldStartVite ? isolateViteBuildOutputPaths(cwd, compileBuildConfig(config)) : compileBuildConfig(config);
+	const deployWranglerConfig = viteProject.shouldStartVite ? isolateViteBuildOutputPaths(cwd, compileBuildConfig(deploymentStrategy.config)) : compileBuildConfig(deploymentStrategy.config);
+	if (viteProject.shouldStartVite) {
+		if (composedMainEntry) {
+			deployWranglerConfig.main = relative(cwd, composedMainEntry);
+			logLine(logger, `Generated composed worker entry: ${deployWranglerConfig.main}`);
+		}
+	} else if (composedMainEntry) {
+		const bundledMainPath = relative(cwd, await bundleWorkerEntry({
+			cwd,
+			inputFile: composedMainEntry,
+			outFile: resolve(cwd, ".devflare", "worker-entrypoints", "main.js"),
+			rolldownOptions: config.rolldown?.options,
+			sourcemap: config.rolldown?.sourcemap,
+			minify: config.rolldown?.minify,
+			logger
+		})).replace(/\\/g, "/");
+		devWranglerConfig.main = bundledMainPath;
+		deployWranglerConfig.main = bundledMainPath;
+		logLine(logger, `Generated bundled worker entry: ${bundledMainPath}`);
+	}
+	let deployConfigPath;
+	if (viteProject.shouldStartVite) {
+		const generatedViteConfigPath = await writeGeneratedViteConfig({
+			cwd,
+			configPath,
+			environment,
+			localConfigPath: viteProject.viteConfigPath
+		});
+		const viteExecutablePath = await resolveLocalViteExecutable(cwd, deps.fs);
+		await cleanupViteBuildOutputs(cwd, devWranglerConfig, logger);
+		logLine(logger, "Running vite build...");
+		const useBunRuntime = isRunningUnderBun();
+		const buildCommand = useBunRuntime ? "bun" : viteExecutablePath;
+		const buildArgs = useBunRuntime ? [
+			"--bun",
+			viteExecutablePath,
+			"build",
+			"--config",
+			generatedViteConfigPath
+		] : [
+			"build",
+			"--config",
+			generatedViteConfigPath
+		];
+		const buildProc = await deps.exec.exec(buildCommand, buildArgs, {
+			cwd,
+			stdio: "inherit",
+			env: {
+				...process.env,
+				DEVFLARE_BUILD: "true"
+			},
+			reject: false
+		});
+		if (buildProc.exitCode !== 0) throw new Error(`Vite build failed (exit code ${buildProc.exitCode}).\n\nCommand: ${buildCommand} ${buildArgs.join(" ")}\nWorking directory: ${cwd}\nVite executable: ${viteExecutablePath}\nRuntime: ${useBunRuntime ? "bun --bun" : "node (default execa runtime)"}\n\nVite's own output is printed above. If you only see "UNHANDLED PROMISE REJECTION"\nwith no other detail, common causes are:\n  - A Vite plugin or transitive dependency (e.g. rolldown) cannot be resolved\n    from the executable's physical path. This commonly happens when the package\n    manager resolves the Vite binary to a global cache directory outside the\n    workspace's node_modules tree. Try reinstalling, or run vite directly to\n    isolate: \`bunx --bun vite build --config ${relative(cwd, generatedViteConfigPath).replace(/\\/g, "/")}\`.\n  - A peer dependency or framework adapter is missing. Re-check the package's\n    devDependencies against the framework's documented requirements.\n  - The generated vite config references a path that does not yet exist.`);
+		const existingDeployConfigPath = await readDeployRedirect(cwd);
+		const generatedDeployConfigPath = deployWranglerConfig.main && deployWranglerConfig.main !== devWranglerConfig.main ? await buildWorkerOnlyDeployArtifact(cwd, deployWranglerConfig, config, logger) : await writeGeneratedDeployWranglerConfig(cwd, deployWranglerConfig);
+		deployConfigPath = existingDeployConfigPath && existingDeployConfigPath !== generatedDeployConfigPath ? existingDeployConfigPath : generatedDeployConfigPath;
+	} else {
+		logLine(logger, "Skipping Vite build (no effective Vite config found for this package)");
+		deployConfigPath = await buildWorkerOnlyDeployArtifact(cwd, deployWranglerConfig, config, logger);
+	}
+	const generatedDevConfigPath = await writeGeneratedDevWranglerConfig(cwd, devWranglerConfig);
+	logger.debug(`Generated dev Wrangler config: ${relative(cwd, generatedDevConfigPath).replace(/\\/g, "/")}`);
+	await writeDeployRedirect(cwd, deployConfigPath);
+	logLine(logger, `Generated deploy Wrangler config: ${relative(cwd, deployConfigPath).replace(/\\/g, "/")}`);
+	logLine(logger, `Generated deploy redirect: ${relative(cwd, getBuildArtifactPaths(cwd).deployRedirectPath).replace(/\\/g, "/")}`);
+	const manifest = createBuildManifest(config, {
+		devflareVersion: await getPackageVersion(),
+		intendedTarget: {
+			environment,
+			preview: parsed.options.preview === true,
+			previewScope: typeof parsed.options.preview === "string" ? parsed.options.preview : void 0,
+			branchName: parsed.options["branch-name"]
+		}
+	});
+	const manifestPath = await writeBuildManifest(getBuildArtifactPaths(cwd).buildDir, manifest);
+	logger.debug(`Generated build manifest: ${relative(cwd, manifestPath).replace(/\\/g, "/")}`);
+	return {
+		config,
+		wranglerConfig: deployWranglerConfig,
+		deployConfigPath,
+		viteProject
+	};
+}
+//#endregion
+export { createBuildManifest as a, compareManifests as i, applyDeploymentStrategy as n, formatDriftWarning as o, describeDeploymentStrategy as r, readBuildManifest as s, prepareBuildArtifacts as t };