camox 0.43.0 → 0.45.0

package/dist/features/vite/vite.js

@@ -1,11 +1,22 @@
-import { generateAppFile, watchAppFile } from "./appGeneration.js";
+import { createServerApiClient } from "../../lib/api-client-server.js";
+import { transformArtifactRuntime } from "./artifactRuntimeMinification.js";
 import { readAuthTokenForUrl } from "./auth.js";
 import { watchNewBlockFiles } from "./blockBoilerplate.js";
+import { collectBlockChunks } from "./blockChunks.js";
+import { withoutExpectedCamoxLogs } from "./bundlerLogs.js";
 import { installDevAuthenticationMiddleware } from "./devAuthentication.js";
-import { syncDefinitions, syncDefinitionsToApi } from "./definitionsSync.js";
+import { installDevSignInLink } from "./devSignIn.js";
+import { generateIconTypes } from "./iconGeneration.js";
+import { generateLayoutFiles, watchLayoutFiles } from "./layoutGeneration.js";
+import { buildClientThenWorker } from "./workerBuild.js";
+import { VIRTUAL_CAMOX_APP, syncDefinitions, syncDefinitionsToApi } from "./definitionsSync.js";
+import { publishSeededContent } from "./publishSeededContent.js";
 import { cleanupGeneratedRouteFiles } from "./routeGeneration.js";
-import { installRuntimeNitroRoutes, loadRuntimeDevModule, resolveRuntimeDevId } from "./runtimeDev.js";
-import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { RESOLVED_VIRTUAL_DEV_HTML, createRuntimeRegistryPlugin, loadRuntimeDevModule, resolveRuntimeDevId } from "./runtimeDev.js";
+import { projectIdSchema } from "@camox/api-contract/ids";
+import { DEVELOPMENT_DRAFT } from "@camox/api-contract/drafts";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createServer } from "vite-plus";
@@ -22,24 +33,136 @@ const VIRTUAL_PAGE_CLIENT = "virtual:camox/page-client";
 const RESOLVED_VIRTUAL_PAGE_CLIENT_URL = "\0virtual:camox/page-client-url";
 const VIRTUAL_STUDIO_CLIENT = "virtual:camox/studio-client";
 const RESOLVED_VIRTUAL_STUDIO_CLIENT_URL = "\0virtual:camox/studio-client-url";
+const RESOLVED_VIRTUAL_BLOCK_CHUNKS = "\0virtual:camox/block-chunks";
 const PRODUCTION_API_URL = "https://api.camox.dev";
 /** Authentication URL to use for Camox authentication (production Camox Dashboard) */
 const DEFAULT_AUTHENTICATION_URL = "https://app.camox.dev";
+/** What Vite injects into HTML in dev, which the Worker can't ask Vite for itself. */
+async function getDevHtml(server) {
+	const html = await server.transformIndexHtml("/", "<html><head></head><body></body></html>");
+	return {
+		head: /<head[^>]*>([\s\S]*)<\/head>/i.exec(html)?.[1] ?? "",
+		body: /<body[^>]*>([\s\S]*)<\/body>/i.exec(html)?.[1] ?? ""
+	};
+}
+/** The `onLog` the app set for its client build, which Camox wraps rather than replaces. */
+function findClientOnLog(config) {
+	const clientBuild = config.environments?.client?.build;
+	return clientBuild?.rolldownOptions?.onLog ?? clientBuild?.rollupOptions?.onLog ?? config.build?.rolldownOptions?.onLog ?? config.build?.rollupOptions?.onLog;
+}
 /**
 * Drop a sidecar at `<root>/node_modules/.camox/runtime.json` so the `camox`
-* CLI can pick up the same projectSlug / apiUrl / authenticationUrl the
+* CLI can pick up the same Project ID / apiUrl / authenticationUrl the
 * plugin actually used. The CLI treats the vite config as the source of
 * truth for those values — there is no other reliable way to recover them
-* from outside vite. The environment is *not* written here: the CLI derives
-* `dev:<email>` from auth at call time and requires `--production` for prod,
-* so a stale build sidecar can't silently route writes to production.
+* from outside vite. No draft is written here: the CLI always works in the
+* developer's development draft (ADR 0010).
 */
 function writeRuntimeSidecar(root, data) {
 	const dir = join(root, "node_modules", ".camox");
 	mkdirSync(dir, { recursive: true });
 	writeFileSync(join(dir, "runtime.json"), `${JSON.stringify(data, null, 2)}\n`);
 }
+const CAMOX_OPTIMIZED_DEPS = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"camox > @base-ui/react/accordion",
+	"camox > @base-ui/react/alert-dialog",
+	"camox > @base-ui/react/avatar",
+	"camox > @base-ui/react/button",
+	"camox > @base-ui/react/checkbox",
+	"camox > @base-ui/react/combobox",
+	"camox > @base-ui/react/dialog",
+	"camox > @base-ui/react/input",
+	"camox > @base-ui/react/menu",
+	"camox > @base-ui/react/merge-props",
+	"camox > @base-ui/react/popover",
+	"camox > @base-ui/react/select",
+	"camox > @base-ui/react/separator",
+	"camox > @base-ui/react/switch",
+	"camox > @base-ui/react/tabs",
+	"camox > @base-ui/react/toggle",
+	"camox > @base-ui/react/tooltip",
+	"camox > @base-ui/react/use-render",
+	"camox > @camox/ui > class-variance-authority",
+	"camox > @camox/ui > clsx",
+	"camox > @camox/ui > cmdk",
+	"camox > @camox/ui > lucide-react",
+	"camox > @camox/ui > @shadcn/react/message-scroller",
+	"camox > @camox/ui > sonner",
+	"camox > @camox/ui > tailwind-merge",
+	"camox > @dnd-kit/core",
+	"camox > @dnd-kit/modifiers",
+	"camox > @dnd-kit/sortable",
+	"camox > @dnd-kit/utilities",
+	"camox > @lexical/react/LexicalComposer",
+	"camox > @lexical/react/LexicalComposerContext",
+	"camox > @lexical/react/LexicalContentEditable",
+	"camox > @lexical/react/LexicalHistoryPlugin",
+	"camox > @lexical/react/LexicalLinkPlugin",
+	"camox > @lexical/react/LexicalOnChangePlugin",
+	"camox > @lexical/react/LexicalRichTextPlugin",
+	"camox > @lexical/link",
+	"camox > @lexical/utils",
+	"camox > @orpc/client",
+	"camox > @orpc/client/fetch",
+	"camox > @orpc/tanstack-query",
+	"camox > @shikijs/core",
+	"camox > @shikijs/engine-javascript",
+	"camox > @shikijs/langs/markdown",
+	"camox > @shikijs/themes/github-dark-high-contrast",
+	"camox > @shikijs/themes/github-light",
+	"camox > @sinclair/typebox",
+	"camox > @takumi-rs/image-response",
+	"camox > @tanstack/react-form",
+	"camox > @tanstack/react-query",
+	"camox > @tanstack/react-router",
+	"camox > @tanstack/react-virtual",
+	"camox > @unhead/react/client",
+	"camox > @unhead/react/server",
+	"camox > @xstate/store",
+	"camox > @xstate/store-react",
+	"camox > better-auth/client/plugins",
+	"camox > better-auth/react",
+	"camox > better-auth > @better-auth/core/env",
+	"camox > better-auth > @better-auth/core/error",
+	"camox > better-auth > @better-auth/core/utils/error-codes",
+	"camox > better-auth > @better-auth/core/utils/string",
+	"camox > better-auth > @better-fetch/fetch",
+	"camox > better-auth > defu",
+	"camox > better-auth > nanostores",
+	"camox > fractional-indexing",
+	"camox > lexical",
+	"camox > lucide-react",
+	"camox > marked",
+	"camox > @tanstack/react-query-devtools/production",
+	"camox > partysocket/react",
+	"camox > zod"
+];
+/**
+* The Worker runs in workerd, so its dependencies are pre-bundled too. Discovering them one
+* request at a time would reload the Worker for each, so start from the browser's list.
+*/
+const CAMOX_WORKER_OPTIMIZED_DEPS = [
+	...CAMOX_OPTIMIZED_DEPS,
+	"react-dom/server",
+	"react/compiler-runtime",
+	"camox > @unhead/react/server"
+];
+/**
+* The Project ID a config names, refused on startup when it is missing or malformed, or when the
+* config still names its project by its Project Slug.
+*/
+function projectIdOf(options) {
+	if ("projectSlug" in options) throw new Error("Camox: `projectSlug` was replaced by `projectId`. Replace it in your camox() config with the Project ID shown in the Camox dashboard, on your project's page.");
+	if (!projectIdSchema.safeParse(options.projectId).success) throw new Error(`Camox: ${JSON.stringify(options.projectId)} is not a Project ID. Copy your project's Project ID, a lowercase UUIDv7, from the Camox dashboard into your camox() config.`);
+	return options.projectId;
+}
 function camox(options) {
+	const projectUuid = projectIdOf(options);
 	const apiUrl = options._internal?.apiUrl ?? PRODUCTION_API_URL;
 	const authenticationUrl = options._internal?.authenticationUrl ?? DEFAULT_AUTHENTICATION_URL;
 	const enableTanstackDevtools = options._internal?.enableTanstackDevtools ?? false;
@@ -47,9 +170,12 @@ function camox(options) {
 	const runtimeBasePath = options._internal?.runtimeBasePath;
 	let isBuild = false;
 	let isRelease = false;
+	/** A release's build, without syncing to Live: what the upgrade job checks a project with. */
+	let isDryRun = false;
 	let resolvedConfig;
-	let environmentName;
 	let localAuth = null;
+	let blockChunks = {};
+	let devServer;
 	return {
 		name: "camox",
 		enforce: "pre",
@@ -59,63 +185,72 @@ function camox(options) {
 			if (id === VIRTUAL_STUDIO_CSS) return RESOLVED_VIRTUAL_STUDIO_CSS;
 			if (id === VIRTUAL_OVERLAY_CSS) return RESOLVED_VIRTUAL_OVERLAY_CSS;
 		},
-		load(id) {
+		async load(id, loadOptions) {
 			const stylesDir = resolve(sdkRoot, !isBuild && isSdkSource ? ".dev" : "dist");
 			if (id === RESOLVED_VIRTUAL_STUDIO_CSS) {
 				const cssPath = resolve(stylesDir, "studio.css");
 				if (isBuild) {
 					const css = readFileSync(cssPath, "utf-8");
-					const dataUrl = `data:text/css;base64,${Buffer.from(css).toString("base64")}`;
-					return `export default ${JSON.stringify(dataUrl)};`;
+					const fileName = `assets/camox-studio-${createHash("sha256").update(css).digest("hex").slice(0, 8)}.css`;
+					this.emitFile({
+						type: "asset",
+						fileName,
+						source: css
+					});
+					return `export default ${JSON.stringify(`/${fileName}`)};`;
 				}
 				const cssUrl = `/@fs/${cssPath.replaceAll("\\", "/").replace(/^\/+/, "")}`;
 				return `export default ${JSON.stringify(cssUrl)};`;
 			}
 			if (id === RESOLVED_VIRTUAL_OVERLAY_CSS) {
-				const css = readFileSync(resolve(stylesDir, "studio-overlays.css"), "utf-8");
+				const cssPath = resolve(stylesDir, "studio-overlays.css");
+				const css = readFileSync(cssPath, "utf-8");
 				return `export default ${JSON.stringify(css)};`;
 			}
 			if (id === RESOLVED_VIRTUAL_PAGE_CLIENT_URL && isBuild) return "export default \"/_chunks/camox-page-client.mjs\";";
 			if (id === RESOLVED_VIRTUAL_STUDIO_CLIENT_URL && isBuild) return "export default \"/_chunks/camox-studio-client.mjs\";";
-			return loadRuntimeDevModule(id, { runtimeBasePath });
-		},
-		nitro: { setup(nitro) {
-			if (nitro.options.noExternals !== true) {
-				const noExternals = Array.isArray(nitro.options.noExternals) ? nitro.options.noExternals : [];
-				nitro.options.noExternals = [
-					...noExternals,
-					"camox",
-					"tslib"
-				];
+			if (id === RESOLVED_VIRTUAL_BLOCK_CHUNKS && isBuild) return `export default ${JSON.stringify(blockChunks)};`;
+			if (id === "\0virtual:camox/dev-html") {
+				if (!devServer) return "export default null;";
+				return `export default ${JSON.stringify(await getDevHtml(devServer))};`;
 			}
-			installRuntimeNitroRoutes(nitro, { runtimeBasePath });
-			nitro.hooks.hook("compiled", ({ options }) => {
-				const serverAssets = join(options.output.serverDir, "assets");
-				if (!existsSync(serverAssets)) return;
-				cpSync(serverAssets, join(options.output.publicDir, "assets"), { recursive: true });
+			return loadRuntimeDevModule(id, {
+				runtimeBasePath,
+				ssr: loadOptions?.ssr
 			});
-		} },
-		config(_config, env) {
+		},
+		transform(code, id) {
+			return transformArtifactRuntime(code, id);
+		},
+		generateBundle(_outputOptions, bundle) {
+			if (this.environment.name !== "client") return;
+			blockChunks = collectBlockChunks(bundle, resolvedConfig.root);
+		},
+		async config(_config, env) {
+			const iconIds = await generateIconTypes(resolve(_config.root ?? process.cwd()), options.icons);
 			isBuild = env.command === "build";
-			isRelease = isBuild && process.env.CAMOX_INTERNAL_RELEASE === "1";
-			if (isRelease) environmentName = "production";
-			else {
+			const release = process.env.CAMOX_INTERNAL_RELEASE;
+			isRelease = isBuild && (release === "1" || release === "dry-run");
+			isDryRun = isRelease && release === "dry-run";
+			if (!isRelease) {
 				localAuth = readAuthTokenForUrl(authenticationUrl);
 				if (isBuild && !localAuth) throw new Error("Camox: not authenticated. Run `npx camox login` before building the site.");
-				environmentName = localAuth ? `dev:${localAuth.email}` : "dev:unauthenticated";
 			}
 			return {
 				build: { emitAssets: true },
+				..._config.builder?.buildApp ? {} : { builder: { buildApp: buildClientThenWorker } },
 				define: {
+					__CAMOX_ICON_IDS__: JSON.stringify(iconIds),
 					__CAMOX_TELEMETRY_DISABLED__: JSON.stringify(!!options.disableTelemetry),
 					__ENABLE_TANSTACK_DEVTOOLS__: JSON.stringify(enableTanstackDevtools),
-					__CAMOX_ENABLE_COMMENTS__: JSON.stringify(options._internal?.enableComments ?? false),
-					__CAMOX_ENVIRONMENT_NAME__: JSON.stringify(environmentName),
+					__CAMOX_ENABLE_EXPERIMENTAL_FEATURES__: JSON.stringify(options._internal?.enableExperimentalFeatures ?? false),
+					__CAMOX_DEVELOPMENT_DRAFT__: JSON.stringify(!isRelease),
 					__CAMOX_API_URL__: JSON.stringify(apiUrl),
 					__CAMOX_AUTHENTICATION_URL__: JSON.stringify(authenticationUrl),
-					__CAMOX_PROJECT_SLUG__: JSON.stringify(options.projectSlug)
+					__CAMOX_PROJECT_ID__: JSON.stringify(projectUuid)
 				},
 				environments: { client: { build: { rollupOptions: {
+					onLog: withoutExpectedCamoxLogs(findClientOnLog(_config)),
 					input: {
 						"camox-page-client": VIRTUAL_PAGE_CLIENT,
 						"camox-studio-client": VIRTUAL_STUDIO_CLIENT
@@ -130,133 +265,112 @@ function camox(options) {
 					find: /^tslib$/,
 					replacement: "tslib/tslib.es6.mjs"
 				}] },
-				optimizeDeps: { include: [
-					"react",
-					"react-dom",
-					"react-dom/client",
-					"react/jsx-runtime",
-					"react/jsx-dev-runtime",
-					"camox > @base-ui/react/accordion",
-					"camox > @base-ui/react/alert-dialog",
-					"camox > @base-ui/react/avatar",
-					"camox > @base-ui/react/dialog",
-					"camox > @base-ui/react/input",
-					"camox > @base-ui/react/menu",
-					"camox > @base-ui/react/merge-props",
-					"camox > @base-ui/react/popover",
-					"camox > @base-ui/react/select",
-					"camox > @base-ui/react/separator",
-					"camox > @base-ui/react/switch",
-					"camox > @base-ui/react/tabs",
-					"camox > @base-ui/react/toggle",
-					"camox > @base-ui/react/tooltip",
-					"camox > @base-ui/react/use-render",
-					"camox > @camox/api-contract",
-					"camox > @camox/api-contract/query-keys",
-					"camox > @camox/ui > cmdk",
-					"camox > @camox/ui > lucide-react",
-					"camox > @camox/ui > sonner",
-					"camox > @dnd-kit/core",
-					"camox > @dnd-kit/modifiers",
-					"camox > @dnd-kit/sortable",
-					"camox > @dnd-kit/utilities",
-					"camox > @lexical/react/LexicalComposer",
-					"camox > @lexical/react/LexicalComposerContext",
-					"camox > @lexical/react/LexicalContentEditable",
-					"camox > @lexical/react/LexicalHistoryPlugin",
-					"camox > @lexical/react/LexicalLinkPlugin",
-					"camox > @lexical/react/LexicalOnChangePlugin",
-					"camox > @lexical/react/LexicalRichTextPlugin",
-					"camox > @lexical/link",
-					"camox > @orpc/client",
-					"camox > @orpc/client/fetch",
-					"camox > @orpc/tanstack-query",
-					"camox > @shikijs/core",
-					"camox > @shikijs/engine-javascript",
-					"camox > @shikijs/langs/markdown",
-					"camox > @shikijs/themes/github-dark-high-contrast",
-					"camox > @shikijs/themes/github-light",
-					"camox > @sinclair/typebox",
-					"camox > @takumi-rs/image-response",
-					"camox > @tanstack/react-form",
-					"camox > @xstate/store-react",
-					"camox > better-auth > @better-auth/core/env",
-					"camox > better-auth > @better-auth/core/error",
-					"camox > better-auth > @better-auth/core/utils/error-codes",
-					"camox > better-auth > @better-auth/core/utils/string",
-					"camox > better-auth > @better-fetch/fetch",
-					"camox > better-auth > defu",
-					"camox > better-auth > nanostores",
-					"camox > fractional-indexing",
-					"camox > lexical",
-					"camox > lucide-react",
-					"camox > @tanstack/react-query-devtools/production",
-					"camox > partysocket/react"
-				] }
+				optimizeDeps: {
+					include: CAMOX_OPTIMIZED_DEPS,
+					exclude: ["@camox/api-contract", "@camox/api-contract/query-keys"]
+				}
+			};
+		},
+		configEnvironment(name, config) {
+			if (name === "client") return;
+			const build = config.build;
+			return {
+				optimizeDeps: {
+					entries: ["src/**/*.{ts,tsx}"],
+					include: CAMOX_WORKER_OPTIMIZED_DEPS,
+					exclude: ["camox"]
+				},
+				build: { rollupOptions: { onLog: withoutExpectedCamoxLogs(build?.rolldownOptions?.onLog ?? build?.rollupOptions?.onLog) } }
 			};
 		},
 		configResolved(config) {
 			resolvedConfig = config;
+			if (!config.plugins.some((plugin) => plugin.name.startsWith("vite-plugin-cloudflare"))) throw new Error("Camox: Camox apps run on Cloudflare Workers. Add `cloudflare()` from `@cloudflare/vite-plugin` to your Vite plugins, and point `main` in `wrangler.jsonc` at `camox/worker`.");
 			const routesDir = resolve(config.root, "src/routes");
 			writeRuntimeSidecar(config.root, {
-				projectSlug: options.projectSlug,
+				projectId: projectUuid,
 				apiUrl,
 				authenticationUrl,
 				disableTelemetry: !!options.disableTelemetry
 			});
 			if (!disableCodeGen) {
-				generateAppFile(config.root);
+				generateLayoutFiles(config.root);
 				cleanupGeneratedRouteFiles(routesDir);
 			}
 			if (disableCodeGen) config.logger.warn("⚠️  Code generation is disabled (_internal.disableCodeGen). This option is only meant for momentary debugging — do not deploy or commit your app with it enabled.", { timestamp: true });
 			const mode = config.command === "serve" ? "Running" : "Building";
-			const environmentLabel = localAuth || isRelease ? environmentName : "authentication required";
-			config.logger.info(`${mode} Camox app (${environmentLabel})`, { timestamp: true });
+			let target = "your development draft";
+			if (isDryRun) target = "Live, dry run";
+			else if (isRelease) target = "Live";
+			else if (!localAuth) target = "authentication required";
+			config.logger.info(`${mode} Camox app (${target})`, { timestamp: true });
 		},
 		configureServer(server) {
+			devServer = server;
 			const routesDir = resolve(server.config.root, "src/routes");
 			installDevAuthenticationMiddleware(server, {
 				apiUrl,
 				authenticationUrl,
 				isAuthenticated: localAuth !== null
 			});
+			if (localAuth?.email) installDevSignInLink(server, {
+				projectUuid,
+				apiUrl,
+				authToken: localAuth.token,
+				open: options._internal?.devSignIn?.open,
+				openOnceFile: options._internal?.devSignIn?.openOnceFile
+			});
 			if (!disableCodeGen) {
-				watchAppFile(server, server.config.root);
+				watchLayoutFiles(server, server.config.root);
 				cleanupGeneratedRouteFiles(routesDir);
 				watchNewBlockFiles(server);
 			}
 			server.httpServer?.once("listening", () => {
 				if (!localAuth) return;
+				const authToken = localAuth.token;
 				syncDefinitions(server, {
-					projectSlug: options.projectSlug,
+					projectUuid,
 					apiUrl,
-					environmentName,
 					autoCreate: true,
-					authToken: localAuth?.token
+					authToken,
+					releaseToEmptyLive: options._internal?.seedLiveDeployToken
+				}).then(async ({ synced, releasedToLive }) => {
+					if (!synced) return;
+					const context = {
+						client: createServerApiClient(apiUrl, authToken, DEVELOPMENT_DRAFT),
+						projectUuid,
+						logger: server.config.logger
+					};
+					const afterSync = options._internal?.afterSync;
+					if (afterSync) try {
+						await afterSync(context);
+					} catch (error) {
+						context.logger.warn(`[camox] afterSync failed: ${String(error)}`, { timestamp: true });
+					}
+					if (releasedToLive) await publishSeededContent(context);
 				});
 			});
 		},
 		async closeBundle() {
-			if (!isRelease) return;
+			if (!isRelease || isDryRun) return;
 			const deployToken = process.env.CAMOX_DEPLOY_TOKEN;
 			if (!deployToken) throw new Error("Camox: CAMOX_DEPLOY_TOKEN is required to release to production.");
-			const camoxAppPath = "./src/camox/app.ts";
 			const tempServer = await createServer({
 				configFile: false,
 				root: resolvedConfig.root,
 				cacheDir: resolve(resolvedConfig.root, "node_modules", ".vite-camox-temp"),
 				resolve: resolvedConfig.resolve,
+				define: resolvedConfig.define,
+				plugins: [createRuntimeRegistryPlugin({ runtimeBasePath })],
 				server: { middlewareMode: true },
 				logLevel: "silent"
 			});
 			try {
-				const camoxModule = await tempServer.ssrLoadModule(camoxAppPath);
-				if (!camoxModule.camoxApp) throw new Error(`No camoxApp export found in ${camoxAppPath}`);
+				const camoxModule = await tempServer.ssrLoadModule(VIRTUAL_CAMOX_APP);
 				await syncDefinitionsToApi({
-					camoxApp: camoxModule.camoxApp,
-					projectSlug: options.projectSlug,
+					definitionSet: await camoxModule.camoxApp.getDefinitionSet(),
+					projectUuid,
 					apiUrl,
-					environmentName,
 					autoCreate: false,
 					deployToken,
 					logger: resolvedConfig.logger
@@ -269,4 +383,4 @@ function camox(options) {
 }
 
 //#endregion
-export { camox };
+export { CAMOX_OPTIMIZED_DEPS, CAMOX_WORKER_OPTIMIZED_DEPS, camox };

package/dist/features/vite/workerBuild.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+//#region src/features/vite/workerBuild.ts
+/**
+* Builds the client first: the Worker's build reads where each block's chunk ended up.
+* This replaces the Cloudflare plugin's order, which builds the Worker first.
+*/
+async function buildClientThenWorker(builder) {
+	const { client, ...servers } = builder.environments;
+	await builder.build(client);
+	const clientDir = resolve(builder.config.root, client.config.build.outDir);
+	for (const server of Object.values(servers)) {
+		await builder.build(server);
+		moveImportedAssets(resolve(builder.config.root, server.config.build.outDir), clientDir);
+	}
+}
+/**
+* Moves the files the Worker imports as URLs, such as stylesheets, to the client's
+* static assets, which serve them. The Cloudflare plugin's own build does the same.
+*/
+function moveImportedAssets(serverDir, clientDir) {
+	const manifestPath = join(serverDir, ".vite", "manifest.json");
+	if (!existsSync(manifestPath)) return;
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+	for (const asset of new Set(Object.values(manifest).flatMap((chunk) => chunk.assets ?? []))) {
+		const from = join(serverDir, asset);
+		const to = join(clientDir, asset);
+		if (!existsSync(from)) continue;
+		if (existsSync(to)) rmSync(from);
+		else {
+			mkdirSync(dirname(to), { recursive: true });
+			renameSync(from, to);
+		}
+	}
+}
+
+//#endregion
+export { buildClientThenWorker };