@valbuild/cli 0.138.0 → 0.138.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @valbuild/cli
 
+## 0.138.2
+
+### Patch Changes
+
+- [#763](https://github.com/valbuild/val/pull/763) [`443cdcd`](https://github.com/valbuild/val/commit/443cdcdfa8948db22a54adef2ad5e18d9f9868e9) Thanks [@freekh](https://github.com/freekh)! - `val publish` now wires the site at the project's branch, which the content service names, instead of the branch the checkout is on. The site's Val saves its edits to the branch it is wired at, so publishing a managed project from a feature branch made every Studio edit land where no publish looks, and Publish answered "nothing to publish". When the two differ, the CLI says so. With a content service that does not name the branch, the checkout's is used, as before.
+- Updated dependencies [[`2beb226`](https://github.com/valbuild/val/commit/2beb226446c76eb71026f43e04c13943da4a1e31), [`cf3bbc8`](https://github.com/valbuild/val/commit/cf3bbc8fc89ff349aac5ab101d0b4f28164583e6), [`443cdcd`](https://github.com/valbuild/val/commit/443cdcdfa8948db22a54adef2ad5e18d9f9868e9)]:
+  - @valbuild/shared@0.138.2
+  - @valbuild/core@0.138.2
+  - @valbuild/server@0.138.2
+  - @valbuild/language-server@0.138.2
+
+## 0.138.1
+
+### Patch Changes
+
+- [#758](https://github.com/valbuild/val/pull/758) [`af57406`](https://github.com/valbuild/val/commit/af57406fb679f5917559a8c97507b7c42f2b48fe) Thanks [@freekh](https://github.com/freekh)! - `val publish` no longer stores a project's stylesheets as its source. It still compiles them, so the site's CSS is unchanged, but the source a managed project's Studio builds from comes without them — as the platform's own publish has always stored it.
+
+  A stored stylesheet broke every Studio publish that followed: a browser build cannot run a Tailwind `@plugin` (the starter's `src/styles.css` has `@plugin "@tailwindcss/typography"`), so it refused the stylesheet and the publish failed with "build failed 3 times". Without one, the Studio ships the live site's CSS, which is right — a Studio edit never changes a stylesheet.
+
+- Updated dependencies []:
+  - @valbuild/server@0.138.1
+  - @valbuild/language-server@0.138.1
+
 ## 0.138.0
 
 ### Minor Changes

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -2351,6 +2351,25 @@ const CODE_FILE = /\.(tsx?|jsx?|mjs|cjs|css)$/;
  */
 const JSON_FILE = /\.json$/;
 
+/**
+ * The project's source as it is STORED, which is what the Studio builds from:
+ * every file this build read, less the stylesheets.
+ *
+ * This build compiles them, because it can run what a stylesheet asks for -- a
+ * Tailwind `@plugin` is a module resolved and executed from `node_modules`. A
+ * build in the browser cannot, and refuses the stylesheet rather than ship a
+ * page that is quietly unstyled; the starter's `src/styles.css` has
+ * `@plugin "@tailwindcss/typography"`. So a stored stylesheet made every
+ * Studio publish after the first one fail. Without it, the Studio's build has
+ * no CSS of its own and ships the live site's (`liveStylesheet` in the
+ * Studio), which is right: a Studio save changes content and uploaded files,
+ * never a stylesheet. It is also what the platform's own publish has always
+ * stored.
+ */
+function withoutStylesheets(sources) {
+  return Object.fromEntries(Object.entries(sources).filter(([key]) => !key.endsWith(".css")));
+}
+
 /**
  * The project's own files: its source as text, and the binaries it imports
  * (an image, a font) base64, as `BuildInput.assets` takes them. `public/` is
@@ -2487,6 +2506,7 @@ async function buildArtifacts(options) {
     // Less the one about the layer, which is the thing this goes on to build.
     warnings.push(...((wiring === null || wiring === void 0 ? void 0 : wiring.warnings) ?? []).filter(warning => !warning.includes("dependency layer built for it")));
     const sources = (wiring === null || wiring === void 0 ? void 0 : wiring.files) ?? onDisk;
+    const projectSource = withoutStylesheets(sources);
 
     // The dependency layer: from what the project imports, of what it declares.
     log("Building the dependency layer");
@@ -2526,9 +2546,10 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
-      // The project's own files, without the generated tree: what the next
-      // publish -- the Studio's included -- starts from.
-      projectSource: sources,
+      // The project's own files, without the generated tree or the
+      // stylesheets: what the next publish -- the Studio's included -- starts
+      // from. See `withoutStylesheets`.
+      projectSource,
       loadCssModule: node.cssModuleLoader(root),
       ...(splitter ? {
         routeSplitter: splitter
@@ -2536,7 +2557,7 @@ async function buildArtifacts(options) {
       rsc: target.project.rsc
     });
     const artifacts = await builder.publishArtifacts(built, {
-      projectSource: sources
+      projectSource
     });
     const dir = options.outDir ?? fs__default$1["default"].mkdtempSync(path__default["default"].join(os__default["default"].tmpdir(), "val-publish-"));
     for (const artifact of artifacts) {
@@ -3121,6 +3142,16 @@ async function runPublish(options) {
     if (collected === null) {
       log("Asking content what to build against");
       const target = await client.buildTarget();
+      /*
+       * Wired at the PROJECT's branch, which content names, not the
+       * checkout's: the build's Val saves its edits to the branch it is wired
+       * at, and a publish only ever commits the project's. Wired at a feature
+       * branch, every Studio edit was saved where no publish looks.
+       */
+      const wiredBranch = target.branch ?? git.branch;
+      if (wiredBranch !== git.branch) {
+        log(`warn: this checkout is on ${git.branch}; the project publishes ${wiredBranch}, ` + `so the site saves its edits to ${wiredBranch}.`);
+      }
       const build = await buildArtifacts({
         root,
         target,
@@ -3128,7 +3159,7 @@ async function runPublish(options) {
         contentHost,
         git: {
           commit: git.commit,
-          branch: git.branch
+          branch: wiredBranch
         },
         env,
         log

package/cli/dist/valbuild-cli-cli.cjs.prod.js

@@ -2351,6 +2351,25 @@ const CODE_FILE = /\.(tsx?|jsx?|mjs|cjs|css)$/;
  */
 const JSON_FILE = /\.json$/;
 
+/**
+ * The project's source as it is STORED, which is what the Studio builds from:
+ * every file this build read, less the stylesheets.
+ *
+ * This build compiles them, because it can run what a stylesheet asks for -- a
+ * Tailwind `@plugin` is a module resolved and executed from `node_modules`. A
+ * build in the browser cannot, and refuses the stylesheet rather than ship a
+ * page that is quietly unstyled; the starter's `src/styles.css` has
+ * `@plugin "@tailwindcss/typography"`. So a stored stylesheet made every
+ * Studio publish after the first one fail. Without it, the Studio's build has
+ * no CSS of its own and ships the live site's (`liveStylesheet` in the
+ * Studio), which is right: a Studio save changes content and uploaded files,
+ * never a stylesheet. It is also what the platform's own publish has always
+ * stored.
+ */
+function withoutStylesheets(sources) {
+  return Object.fromEntries(Object.entries(sources).filter(([key]) => !key.endsWith(".css")));
+}
+
 /**
  * The project's own files: its source as text, and the binaries it imports
  * (an image, a font) base64, as `BuildInput.assets` takes them. `public/` is
@@ -2487,6 +2506,7 @@ async function buildArtifacts(options) {
     // Less the one about the layer, which is the thing this goes on to build.
     warnings.push(...((wiring === null || wiring === void 0 ? void 0 : wiring.warnings) ?? []).filter(warning => !warning.includes("dependency layer built for it")));
     const sources = (wiring === null || wiring === void 0 ? void 0 : wiring.files) ?? onDisk;
+    const projectSource = withoutStylesheets(sources);
 
     // The dependency layer: from what the project imports, of what it declares.
     log("Building the dependency layer");
@@ -2526,9 +2546,10 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
-      // The project's own files, without the generated tree: what the next
-      // publish -- the Studio's included -- starts from.
-      projectSource: sources,
+      // The project's own files, without the generated tree or the
+      // stylesheets: what the next publish -- the Studio's included -- starts
+      // from. See `withoutStylesheets`.
+      projectSource,
       loadCssModule: node.cssModuleLoader(root),
       ...(splitter ? {
         routeSplitter: splitter
@@ -2536,7 +2557,7 @@ async function buildArtifacts(options) {
       rsc: target.project.rsc
     });
     const artifacts = await builder.publishArtifacts(built, {
-      projectSource: sources
+      projectSource
     });
     const dir = options.outDir ?? fs__default$1["default"].mkdtempSync(path__default["default"].join(os__default["default"].tmpdir(), "val-publish-"));
     for (const artifact of artifacts) {
@@ -3121,6 +3142,16 @@ async function runPublish(options) {
     if (collected === null) {
       log("Asking content what to build against");
       const target = await client.buildTarget();
+      /*
+       * Wired at the PROJECT's branch, which content names, not the
+       * checkout's: the build's Val saves its edits to the branch it is wired
+       * at, and a publish only ever commits the project's. Wired at a feature
+       * branch, every Studio edit was saved where no publish looks.
+       */
+      const wiredBranch = target.branch ?? git.branch;
+      if (wiredBranch !== git.branch) {
+        log(`warn: this checkout is on ${git.branch}; the project publishes ${wiredBranch}, ` + `so the site saves its edits to ${wiredBranch}.`);
+      }
       const build = await buildArtifacts({
         root,
         target,
@@ -3128,7 +3159,7 @@ async function runPublish(options) {
         contentHost,
         git: {
           commit: git.commit,
-          branch: git.branch
+          branch: wiredBranch
         },
         env,
         log

package/cli/dist/valbuild-cli-cli.esm.js

@@ -2316,6 +2316,25 @@ const CODE_FILE = /\.(tsx?|jsx?|mjs|cjs|css)$/;
  */
 const JSON_FILE = /\.json$/;
 
+/**
+ * The project's source as it is STORED, which is what the Studio builds from:
+ * every file this build read, less the stylesheets.
+ *
+ * This build compiles them, because it can run what a stylesheet asks for -- a
+ * Tailwind `@plugin` is a module resolved and executed from `node_modules`. A
+ * build in the browser cannot, and refuses the stylesheet rather than ship a
+ * page that is quietly unstyled; the starter's `src/styles.css` has
+ * `@plugin "@tailwindcss/typography"`. So a stored stylesheet made every
+ * Studio publish after the first one fail. Without it, the Studio's build has
+ * no CSS of its own and ships the live site's (`liveStylesheet` in the
+ * Studio), which is right: a Studio save changes content and uploaded files,
+ * never a stylesheet. It is also what the platform's own publish has always
+ * stored.
+ */
+function withoutStylesheets(sources) {
+  return Object.fromEntries(Object.entries(sources).filter(([key]) => !key.endsWith(".css")));
+}
+
 /**
  * The project's own files: its source as text, and the binaries it imports
  * (an image, a font) base64, as `BuildInput.assets` takes them. `public/` is
@@ -2452,6 +2471,7 @@ async function buildArtifacts(options) {
     // Less the one about the layer, which is the thing this goes on to build.
     warnings.push(...((wiring === null || wiring === void 0 ? void 0 : wiring.warnings) ?? []).filter(warning => !warning.includes("dependency layer built for it")));
     const sources = (wiring === null || wiring === void 0 ? void 0 : wiring.files) ?? onDisk;
+    const projectSource = withoutStylesheets(sources);
 
     // The dependency layer: from what the project imports, of what it declares.
     log("Building the dependency layer");
@@ -2491,9 +2511,10 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
-      // The project's own files, without the generated tree: what the next
-      // publish -- the Studio's included -- starts from.
-      projectSource: sources,
+      // The project's own files, without the generated tree or the
+      // stylesheets: what the next publish -- the Studio's included -- starts
+      // from. See `withoutStylesheets`.
+      projectSource,
       loadCssModule: node.cssModuleLoader(root),
       ...(splitter ? {
         routeSplitter: splitter
@@ -2501,7 +2522,7 @@ async function buildArtifacts(options) {
       rsc: target.project.rsc
     });
     const artifacts = await builder.publishArtifacts(built, {
-      projectSource: sources
+      projectSource
     });
     const dir = options.outDir ?? fs$1.mkdtempSync(path.join(os.tmpdir(), "val-publish-"));
     for (const artifact of artifacts) {
@@ -3086,6 +3107,16 @@ async function runPublish(options) {
     if (collected === null) {
       log("Asking content what to build against");
       const target = await client.buildTarget();
+      /*
+       * Wired at the PROJECT's branch, which content names, not the
+       * checkout's: the build's Val saves its edits to the branch it is wired
+       * at, and a publish only ever commits the project's. Wired at a feature
+       * branch, every Studio edit was saved where no publish looks.
+       */
+      const wiredBranch = target.branch ?? git.branch;
+      if (wiredBranch !== git.branch) {
+        log(`warn: this checkout is on ${git.branch}; the project publishes ${wiredBranch}, ` + `so the site saves its edits to ${wiredBranch}.`);
+      }
       const build = await buildArtifacts({
         root,
         target,
@@ -3093,7 +3124,7 @@ async function runPublish(options) {
         contentHost,
         git: {
           commit: git.commit,
-          branch: git.branch
+          branch: wiredBranch
         },
         env,
         log

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.138.0",
+  "version": "0.138.2",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -26,11 +26,11 @@
     "picocolors": "^1.1.1",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.138.0",
+    "@valbuild/core": "0.138.2",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/language-server": "0.138.0",
-    "@valbuild/server": "0.138.0",
-    "@valbuild/shared": "0.138.0"
+    "@valbuild/language-server": "0.138.2",
+    "@valbuild/server": "0.138.2",
+    "@valbuild/shared": "0.138.2"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/publish/__fixtures__/buildPublishProbe.ts

@@ -68,6 +68,9 @@ export const Route = createFileRoute("/build/")({
 });
 `,
   "src/styles.css": `h1 { color: rebeccapurple; }\n`,
+  // A Val project, so the publish wires it -- and wires it at a branch.
+  "val.config.ts": `export const config = { project: "acme/site" };\n`,
+  "val.modules.ts": `export default { modules: [] };\n`,
   "public/robots.txt": "User-agent: *\n",
 };
 
@@ -86,6 +89,10 @@ type Report = {
   uploadedLayerRev: string | null;
   /** Whether the source artifact holds the project's own route file. */
   sourceHasRoute: boolean;
+  /** Whether the source artifact holds a stylesheet -- it must not. */
+  sourceHasStylesheet: boolean;
+  /** Whether the stylesheet was compiled into the site's CSS all the same. */
+  cssHasRule: boolean;
   /** Whether the client build carries the page's text. */
   clientHasPage: boolean;
   /** Whether the imported image reached the build, inlined. */
@@ -94,6 +101,10 @@ type Report = {
   buildRouteBuilt: boolean;
   /** Whether the checkout was left exactly as it was found. */
   checkoutUntouched: boolean;
+  /** The branch the stored `val.server.ts` is wired at. */
+  wiredBranch: string | null;
+  /** Whether the run warned that the checkout's branch is not the project's. */
+  warnedAboutBranch: boolean;
 };
 
 /** A 1x1 PNG: small enough to inline, so the page carries it as a data URI. */
@@ -135,15 +146,19 @@ function listed(root: string): string[] {
 async function publishOnce(
   root: string,
   fake: FakeContentService,
+  branch = "main",
 ): Promise<Report> {
   const before = listed(root);
+  const logged: string[] = [];
   const result = await runPublish({
     root,
     commit: COMMIT,
-    branch: "main",
+    branch,
     env: { VAL_PROJECT_TOKEN: TOKEN, VAL_CONTENT_URL: fake.url },
     sleep: () => Promise.resolve(),
-    log: () => undefined,
+    log: (line: string) => {
+      logged.push(line);
+    },
   });
   const declared = [...fake.declarations.values()].map((body) => {
     const d = body as {
@@ -183,6 +198,14 @@ async function publishOnce(
       ? "src/routes/index.tsx" in
         (JSON.parse(source.toString("utf8")) as Record<string, string>)
       : false,
+    sourceHasStylesheet: source
+      ? Object.keys(
+          JSON.parse(source.toString("utf8")) as Record<string, string>,
+        ).some((key) => key.endsWith(".css"))
+      : false,
+    cssHasRule: (fake.stored.get("css")?.toString("utf8") ?? "").includes(
+      "rebeccapurple",
+    ),
     clientHasPage: clientText.includes("hello from the checkout"),
     clientHasLogo: clientText.includes(
       `data:image/png;base64,${LOGO.toString("base64")}`,
@@ -194,9 +217,25 @@ async function publishOnce(
           (JSON.parse(source.toString("utf8")) as Record<string, string>)
         : false),
     checkoutUntouched: JSON.stringify(listed(root)) === JSON.stringify(before),
+    wiredBranch: source ? wiredBranchOf(source) : null,
+    warnedAboutBranch: logged.some(
+      (line) => line.startsWith("warn:") && line.includes("publishes"),
+    ),
   };
 }
 
+/** The branch the stored `val.server.ts` was wired at: its `BUILT_FROM`. */
+function wiredBranchOf(source: Buffer): string | null {
+  const files = JSON.parse(source.toString("utf8")) as Record<string, string>;
+  const server = Object.entries(files).find(([key]) =>
+    key.endsWith("val.server.ts"),
+  )?.[1];
+  const match = server ? /^const BUILT_FROM = (.+);$/m.exec(server) : null;
+  if (!match?.[1] || match[1] === "null") return null;
+  const parsed = JSON.parse(match[1]) as { branch?: unknown };
+  return typeof parsed.branch === "string" ? parsed.branch : null;
+}
+
 (async () => {
   const root = writeProject();
   try {
@@ -216,7 +255,16 @@ async function publishOnce(
     });
     const held = await publishOnce(root, second).finally(() => second.close());
 
-    process.stdout.write(`${JSON.stringify({ fresh, held })}\n`);
+    // From a checkout on a feature branch, of a project content says is on main.
+    const third = await startFakeContentService({
+      token: TOKEN,
+      buildTarget: { ...FAKE_BUILD_TARGET, branch: "main" },
+    });
+    const elsewhere = await publishOnce(root, third, "feature/x").finally(() =>
+      third.close(),
+    );
+
+    process.stdout.write(`${JSON.stringify({ fresh, held, elsewhere })}\n`);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }

package/src/publish/buildArtifacts.ts

@@ -97,6 +97,29 @@ const CODE_FILE = /\.(tsx?|jsx?|mjs|cjs|css)$/;
  */
 const JSON_FILE = /\.json$/;
 
+/**
+ * The project's source as it is STORED, which is what the Studio builds from:
+ * every file this build read, less the stylesheets.
+ *
+ * This build compiles them, because it can run what a stylesheet asks for -- a
+ * Tailwind `@plugin` is a module resolved and executed from `node_modules`. A
+ * build in the browser cannot, and refuses the stylesheet rather than ship a
+ * page that is quietly unstyled; the starter's `src/styles.css` has
+ * `@plugin "@tailwindcss/typography"`. So a stored stylesheet made every
+ * Studio publish after the first one fail. Without it, the Studio's build has
+ * no CSS of its own and ships the live site's (`liveStylesheet` in the
+ * Studio), which is right: a Studio save changes content and uploaded files,
+ * never a stylesheet. It is also what the platform's own publish has always
+ * stored.
+ */
+export function withoutStylesheets(
+  sources: Record<string, string>,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(sources).filter(([key]) => !key.endsWith(".css")),
+  );
+}
+
 /**
  * The project's own files: its source as text, and the binaries it imports
  * (an image, a font) base64, as `BuildInput.assets` takes them. `public/` is
@@ -244,6 +267,7 @@ export async function buildArtifacts(options: {
       ),
     );
     const sources = wiring?.files ?? onDisk;
+    const projectSource = withoutStylesheets(sources);
 
     // The dependency layer: from what the project imports, of what it declares.
     log("Building the dependency layer");
@@ -295,15 +319,16 @@ export async function buildArtifacts(options: {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
-      // The project's own files, without the generated tree: what the next
-      // publish -- the Studio's included -- starts from.
-      projectSource: sources,
+      // The project's own files, without the generated tree or the
+      // stylesheets: what the next publish -- the Studio's included -- starts
+      // from. See `withoutStylesheets`.
+      projectSource,
       loadCssModule: node.cssModuleLoader(root),
       ...(splitter ? { routeSplitter: splitter } : {}),
       rsc: target.project.rsc,
     });
     const artifacts: PublishArtifact[] = await builder.publishArtifacts(built, {
-      projectSource: sources,
+      projectSource,
     });
 
     const dir =

package/src/publish/buildPublish.test.ts

@@ -29,13 +29,17 @@ type Run = {
   buildTargetCalls: number;
   uploadedLayerRev: string | null;
   sourceHasRoute: boolean;
+  sourceHasStylesheet: boolean;
+  cssHasRule: boolean;
   clientHasPage: boolean;
   clientHasLogo: boolean;
   buildRouteBuilt: boolean;
   checkoutUntouched: boolean;
+  wiredBranch: string | null;
+  warnedAboutBranch: boolean;
 };
 
-let probe: { fresh: Run; held: Run };
+let probe: { fresh: Run; held: Run; elsewhere: Run };
 
 beforeAll(() => {
   const out = execFileSync(
@@ -76,6 +80,14 @@ test("the stored source is the project's own files", () => {
   expect(probe.fresh.sourceHasRoute).toBe(true);
 });
 
+test("a stylesheet is built, and not stored as source", () => {
+  // The Studio builds from the stored source, in a browser that cannot run a
+  // Tailwind `@plugin`; a stored stylesheet failed every Studio publish after
+  // the first. Without one it ships the live site's CSS, compiled here.
+  expect(probe.fresh.cssHasRule).toBe(true);
+  expect(probe.fresh.sourceHasStylesheet).toBe(false);
+});
+
 test("an image the project imports reaches the build", () => {
   expect(probe.fresh.clientHasLogo).toBe(true);
 });
@@ -100,6 +112,18 @@ test("a layer content already holds is named, not sent again", () => {
   expect(held.declared[0]!.buildHash).toBe(fresh.declared[0]!.buildHash);
 });
 
+test("a checkout on another branch is wired at the project's, and says so", () => {
+  // Content names the project's branch; the site's Val saves its edits to the
+  // branch it is wired at, so a feature branch here was a site whose every
+  // Studio edit went where no publish looks.
+  expect(probe.elsewhere.result.status).toBe("live");
+  expect(probe.elsewhere.wiredBranch).toBe("main");
+  expect(probe.elsewhere.warnedAboutBranch).toBe(true);
+  // Where they agree there is nothing to say.
+  expect(probe.fresh.wiredBranch).toBe("main");
+  expect(probe.fresh.warnedAboutBranch).toBe(false);
+});
+
 test("the checkout is left as it was found", () => {
   // The route tree is generated on disk and put back; the build is written
   // to a temporary directory, not into `.val/publish`.

package/src/publish/runPublish.ts

@@ -172,12 +172,25 @@ export async function runPublish(
     if (collected === null) {
       log("Asking content what to build against");
       const target = await client.buildTarget();
+      /*
+       * Wired at the PROJECT's branch, which content names, not the
+       * checkout's: the build's Val saves its edits to the branch it is wired
+       * at, and a publish only ever commits the project's. Wired at a feature
+       * branch, every Studio edit was saved where no publish looks.
+       */
+      const wiredBranch = target.branch ?? git.branch;
+      if (wiredBranch !== git.branch) {
+        log(
+          `warn: this checkout is on ${git.branch}; the project publishes ${wiredBranch}, ` +
+            `so the site saves its edits to ${wiredBranch}.`,
+        );
+      }
       const build = await buildArtifacts({
         root,
         target,
         project: project ?? "",
         contentHost,
-        git: { commit: git.commit, branch: git.branch },
+        git: { commit: git.commit, branch: wiredBranch },
         env,
         log,
       });