@valbuild/cli 0.138.1 → 0.138.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @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

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

@@ -3142,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,
@@ -3149,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

@@ -3142,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,
@@ -3149,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

@@ -3107,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,
@@ -3114,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.1",
+  "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.1",
-    "@valbuild/server": "0.138.1",
-    "@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",
 };
 
@@ -98,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. */
@@ -139,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 {
@@ -206,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 {
@@ -228,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/buildPublish.test.ts

@@ -35,9 +35,11 @@ type Run = {
   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(
@@ -110,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,
       });