@valbuild/shared 0.138.0 → 0.138.4

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @valbuild/shared
 
+## 0.138.4
+
+### Patch Changes
+
+- [#770](https://github.com/valbuild/val/pull/770) [`0a885b1`](https://github.com/valbuild/val/commit/0a885b1f0304517b167b959958464066194732d0) Thanks [@freekh](https://github.com/freekh)! - Publishing a Git-connected app-mode project now puts your changes on the site in seconds, instead of waiting for CI.
+
+  - The Studio builds the site in the browser, the same way it does for a managed project. Val pushes the commit to your repository as before. When nothing but content has changed since the build the site is serving, the browser's build goes live right away. If a developer has pushed code in between, the site waits for CI's build, so their code is never taken off the site.
+  - If the browser cannot build, the publish still goes through and CI delivers it. This happens when the page is not cross-origin isolated, or when the build keeps failing. Your changes stay visible in the Studio until the site serves a build that has them.
+  - Content that would break a page is caught before anything is pushed to your repository.
+
+- [#771](https://github.com/valbuild/val/pull/771) [`58d13a2`](https://github.com/valbuild/val/commit/58d13a2a534421b341b1bf71d02f0a2290fc0d61) Thanks [@freekh](https://github.com/freekh)! - A project created on val.build with a GitHub repository can publish right away. Before, the first publish was refused with "this deployment was not built from one" until the repository's first CI build had finished.
+
+  While that first build runs, the site is served the template's build. When you publish from it, Val now checks that its content files are exactly the same as the files in your repository. If they are, the publish goes ahead and is pushed to your repository straight away. Your changes stay visible in the Studio until the site serves CI's build of them. If the files differ, the publish is refused, as before.
+
+## 0.138.2
+
+### Patch Changes
+
+- [#763](https://github.com/valbuild/val/pull/763) [`2beb226`](https://github.com/valbuild/val/commit/2beb226446c76eb71026f43e04c13943da4a1e31) Thanks [@freekh](https://github.com/freekh)! - When a publish fails because the Studio could not build the site, the editor is now told why. The tab that built it sends its reason with the failed step, so the message reads, for example, "build failed 3 times: Tailwind's '@plugin' is not supported here…" instead of just "build failed 3 times". This needs the content service that accepts the reason; an older one ignores it and shows the message as before.
+
+- [#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 [[`cf3bbc8`](https://github.com/valbuild/val/commit/cf3bbc8fc89ff349aac5ab101d0b4f28164583e6)]:
+  - @valbuild/core@0.138.2
+
 ## 0.138.0
 
 ### Minor Changes

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -1134,6 +1134,7 @@ export declare const Api: {
                     binaryFiles: z.ZodRecord<z.ZodString, z.ZodString>;
                     binaryFilesUnread: z.ZodArray<z.ZodString>;
                     branch: z.ZodNullable<z.ZodString>;
+                    buildable: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>;
         };

package/dist/declarations/src/internal/publish/contentApi.d.ts

@@ -296,6 +296,20 @@ export type ContentPublishApi = {
                  * branch whose tip is that commit has nothing it has not seen.
                  */
                 gitCommit?: string;
+                /**
+                 * Connected: the tab can build this job (the deployment embeds its
+                 * source). Without it, content goes on to the seal with no build and
+                 * CI builds the push -- which is what a server that predates tab
+                 * builds gets, since it never says so.
+                 */
+                tabBuilds?: true;
+                /**
+                 * Connected, a deployment built from no commit: its Val source files
+                 * (modules and `val.modules.*`), by path from the project root, as git
+                 * blob shas. The content service compares them with the branch when
+                 * there is no commit to compare from.
+                 */
+                deploymentFiles?: Record<string, string>;
             };
             res: {
                 job: PublishTabJob | null;
@@ -310,6 +324,17 @@ export type ContentPublishApi = {
                 ok: boolean;
                 /** A finished build step: the id of the publish (`POST /publish`) it declared. */
                 build?: string;
+                /**
+                 * Connected, at `build`, instead of `build`: this tab cannot build
+                 * (no cross-origin isolation, or a deployment that embeds no source).
+                 * The job goes on without one, and CI builds the push.
+                 */
+                noBuild?: true;
+                /**
+                 * A failed step: why, in the tab's words. The step is still retried;
+                 * if it fails for good, this is what the editor is told.
+                 */
+                message?: string;
             };
             res: {
                 job: PublishTabJob | null;

package/dist/declarations/src/internal/publish/protocol.d.ts

@@ -96,6 +96,7 @@ declare const buildTargetResponse: z.ZodObject<{
         css: z.ZodRecord<z.ZodString, z.ZodString>;
         workerOnly: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type BuildTargetResponse = z.infer<typeof buildTargetResponse>;
 /**
@@ -184,6 +185,7 @@ declare const updateTargetResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
             css: z.ZodRecord<z.ZodString, z.ZodString>;
             workerOnly: z.ZodArray<z.ZodString>;
         }, z.core.$strip>;
+        branch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"unavailable">;

package/internal/dist/valbuild-shared-internal.cjs.dev.js

@@ -2657,7 +2657,14 @@ var Api = {
           /** Binary files whose bytes could not be read back. */
           binaryFilesUnread: zod.z.array(zod.z.string()),
           /** The branch the job publishes to. */
-          branch: zod.z.string().nullable()
+          branch: zod.z.string().nullable(),
+          /**
+           * Can the tab build the job from `sourceFiles`? False for a
+           * connected deployment that embeds no source: the tab reports
+           * "no build", and CI builds the push. Absent from older servers,
+           * which only answered buildable jobs.
+           */
+          buildable: zod.z["boolean"]().optional()
         })
       })])
     }
@@ -7442,7 +7449,12 @@ var buildTargetResponse = zod.z.object({
     modules: zod.z.record(zod.z.string(), zod.z.string()),
     css: zod.z.record(zod.z.string(), zod.z.string()),
     workerOnly: zod.z.array(zod.z.string())
-  })
+  }),
+  /**
+   * The project's branch: what a build is wired at, so its Val saves where
+   * publishes commit. Optional, for a content service that predates it.
+   */
+  branch: zod.z.string().optional()
 });
 /**
  * `null` files is a real answer: a project that has never published.

package/internal/dist/valbuild-shared-internal.cjs.prod.js

@@ -2657,7 +2657,14 @@ var Api = {
           /** Binary files whose bytes could not be read back. */
           binaryFilesUnread: zod.z.array(zod.z.string()),
           /** The branch the job publishes to. */
-          branch: zod.z.string().nullable()
+          branch: zod.z.string().nullable(),
+          /**
+           * Can the tab build the job from `sourceFiles`? False for a
+           * connected deployment that embeds no source: the tab reports
+           * "no build", and CI builds the push. Absent from older servers,
+           * which only answered buildable jobs.
+           */
+          buildable: zod.z["boolean"]().optional()
         })
       })])
     }
@@ -7442,7 +7449,12 @@ var buildTargetResponse = zod.z.object({
     modules: zod.z.record(zod.z.string(), zod.z.string()),
     css: zod.z.record(zod.z.string(), zod.z.string()),
     workerOnly: zod.z.array(zod.z.string())
-  })
+  }),
+  /**
+   * The project's branch: what a build is wired at, so its Val saves where
+   * publishes commit. Optional, for a content service that predates it.
+   */
+  branch: zod.z.string().optional()
 });
 /**
  * `null` files is a real answer: a project that has never published.

package/internal/dist/valbuild-shared-internal.esm.js

@@ -2650,7 +2650,14 @@ var Api = {
           /** Binary files whose bytes could not be read back. */
           binaryFilesUnread: z.array(z.string()),
           /** The branch the job publishes to. */
-          branch: z.string().nullable()
+          branch: z.string().nullable(),
+          /**
+           * Can the tab build the job from `sourceFiles`? False for a
+           * connected deployment that embeds no source: the tab reports
+           * "no build", and CI builds the push. Absent from older servers,
+           * which only answered buildable jobs.
+           */
+          buildable: z["boolean"]().optional()
         })
       })])
     }
@@ -7435,7 +7442,12 @@ var buildTargetResponse = z.object({
     modules: z.record(z.string(), z.string()),
     css: z.record(z.string(), z.string()),
     workerOnly: z.array(z.string())
-  })
+  }),
+  /**
+   * The project's branch: what a build is wired at, so its Val saves where
+   * publishes commit. Optional, for a content service that predates it.
+   */
+  branch: z.string().optional()
 });
 /**
  * `null` files is a real answer: a project that has never published.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/shared",
-  "version": "0.138.0",
+  "version": "0.138.4",
   "private": false,
   "description": "Val shared types and utilities",
   "repository": {
@@ -37,7 +37,7 @@
     "flexsearch": "^0.8.212",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.138.0"
+    "@valbuild/core": "0.138.2"
   },
   "files": [
     "CHANGELOG.md",