@valbuild/shared 0.136.1 → 0.136.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @valbuild/shared
 
+## 0.136.2
+
+### Patch Changes
+
+- [#720](https://github.com/valbuild/val/pull/720) [`f76cd56`](https://github.com/valbuild/val/commit/f76cd56b9f1c1bcc0a608a7a4de24b1e776adccb) Thanks [@freekh](https://github.com/freekh)! - A managed project published from the Studio keeps its images, and a project created from a template can publish from the Studio at all.
+
+  - A publish from the Studio carries over every file under `public/` that the site already serves, so the favicon and images no longer disappear after the first Studio publish. When content published the live build, it already holds those files and nothing is uploaded again. When it didn't (a project cloned from a template), the Studio reads them from the site it runs on and builds with them.
+  - An image uploaded in the Studio is now part of the build that publishes it. For a managed project, `/save` returns the files the commit wrote (`binaryFiles`), the same way it already returns the `.val.ts` text.
+  - `/save` also returns the project's branch for a managed project, and the Studio's build uses it. A project cloned from a template was wired at no commit and no branch, so its first Studio publish went out branchless and the platform refused it.
+  - When neither content nor the platform can say which public files the live site serves, the Studio refuses to publish and says so, rather than publishing a site without them.
+
 ## 0.136.1
 
 ### Patch Changes

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

@@ -1077,6 +1077,9 @@ export declare const Api: {
                 json: z.ZodObject<{
                     commitSha: z.ZodOptional<z.ZodString>;
                     sourceFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+                    binaryFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    branch: z.ZodOptional<z.ZodString>;
+                    binaryFilesUnread: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     removed: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         patchId: z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>;
                         moduleFilePath: z.ZodString & z.ZodType<ModuleFilePath, string, z.core.$ZodTypeInternals<ModuleFilePath, string>>;

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

@@ -107,6 +107,12 @@ export type BuildTargetResponse = z.infer<typeof buildTargetResponse>;
  */
 declare const projectSourceResponse: z.ZodObject<{
     files: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    publicFiles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    publicPaths: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 export type ProjectSourceResponse = z.infer<typeof projectSourceResponse>;
 export declare const parseBuildTarget: (body: unknown) => BuildTargetResponse;

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

@@ -2606,6 +2606,34 @@ var Api = {
            * repository, and from a server that predates it.
            */
           sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
+          /**
+           * The binary files this commit wrote -- an image uploaded in the
+           * Studio -- base64, by path, for a MANAGED project.
+           *
+           * The same reason as `sourceFiles`: the in-tab build publishes the
+           * site, and a file this commit added is in no earlier build. Local
+           * files only; a remote one is served from its own URL and was never
+           * part of a build. A deleted file is a `null` in `sourceFiles`, as
+           * it always was.
+           */
+          binaryFiles: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+          /**
+           * The branch this commit is on, for a MANAGED project -- the
+           * content service's word for it.
+           *
+           * The in-tab build has to name the branch it was made at, and its
+           * only other source is the `val.server.ts` the last build was
+           * wired with: a project cloned from a template seed has one wired
+           * at no commit, so without this its first publish is branchless
+           * and the loader refuses it.
+           */
+          branch: zod.z.string().optional(),
+          /**
+           * Binary files this commit wrote whose bytes the server could not
+           * read back before committing. Named so the Studio refuses to build
+           * a site that would 404 them, rather than publishing it.
+           */
+          binaryFilesUnread: zod.z.array(zod.z.string()).optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -7231,7 +7259,37 @@ var buildTargetResponse = zod.z.object({
  * "there is nothing here yet".
  */
 var projectSourceResponse = zod.z.object({
-  files: zod.z.record(zod.z.string(), zod.z.string()).nullable()
+  files: zod.z.record(zod.z.string(), zod.z.string()).nullable(),
+  /**
+   * The live build's `public/*` artifacts, by hash -- what a publisher with no
+   * checkout carries into its build so the site keeps its favicon and images.
+   *
+   * The loader stores public files PER BUILD, so a build that names none
+   * serves none. A publisher with a checkout has them on disk; the Studio has
+   * this. Re-declaring one costs nothing: content holds the bytes for the
+   * project already and asks for no upload.
+   *
+   * `null` when content cannot say -- the live build was not published through
+   * it -- and absent from a content service that predates it. A publisher
+   * must treat both as "unknown", never as "none": publishing on that guess
+   * deletes every public file the site has.
+   */
+  publicFiles: zod.z.array(zod.z.object({
+    key: zod.z.string(),
+    sha256: zod.z.string(),
+    bytes: zod.z.number()["int"]().nonnegative()
+  })).nullable().optional(),
+  /**
+   * The URL paths the live build serves from `public/`, as the loader has
+   * them -- without the bytes' hashes.
+   *
+   * The fallback for when `publicFiles` is `null`: a build content has no
+   * record of, which is every project cloned from a template seed. A publisher
+   * running on the site's own origin can fetch these and build with them;
+   * after that publish content holds their hashes and `publicFiles` answers.
+   * `null` when the loader serves no build or does not say.
+   */
+  publicPaths: zod.z.array(zod.z.string()).nullable().optional()
 });
 var parseBuildTarget = function parseBuildTarget(body) {
   return parse(buildTargetResponse, body, "GET /v1/build-target");

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

@@ -2606,6 +2606,34 @@ var Api = {
            * repository, and from a server that predates it.
            */
           sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
+          /**
+           * The binary files this commit wrote -- an image uploaded in the
+           * Studio -- base64, by path, for a MANAGED project.
+           *
+           * The same reason as `sourceFiles`: the in-tab build publishes the
+           * site, and a file this commit added is in no earlier build. Local
+           * files only; a remote one is served from its own URL and was never
+           * part of a build. A deleted file is a `null` in `sourceFiles`, as
+           * it always was.
+           */
+          binaryFiles: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+          /**
+           * The branch this commit is on, for a MANAGED project -- the
+           * content service's word for it.
+           *
+           * The in-tab build has to name the branch it was made at, and its
+           * only other source is the `val.server.ts` the last build was
+           * wired with: a project cloned from a template seed has one wired
+           * at no commit, so without this its first publish is branchless
+           * and the loader refuses it.
+           */
+          branch: zod.z.string().optional(),
+          /**
+           * Binary files this commit wrote whose bytes the server could not
+           * read back before committing. Named so the Studio refuses to build
+           * a site that would 404 them, rather than publishing it.
+           */
+          binaryFilesUnread: zod.z.array(zod.z.string()).optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -7231,7 +7259,37 @@ var buildTargetResponse = zod.z.object({
  * "there is nothing here yet".
  */
 var projectSourceResponse = zod.z.object({
-  files: zod.z.record(zod.z.string(), zod.z.string()).nullable()
+  files: zod.z.record(zod.z.string(), zod.z.string()).nullable(),
+  /**
+   * The live build's `public/*` artifacts, by hash -- what a publisher with no
+   * checkout carries into its build so the site keeps its favicon and images.
+   *
+   * The loader stores public files PER BUILD, so a build that names none
+   * serves none. A publisher with a checkout has them on disk; the Studio has
+   * this. Re-declaring one costs nothing: content holds the bytes for the
+   * project already and asks for no upload.
+   *
+   * `null` when content cannot say -- the live build was not published through
+   * it -- and absent from a content service that predates it. A publisher
+   * must treat both as "unknown", never as "none": publishing on that guess
+   * deletes every public file the site has.
+   */
+  publicFiles: zod.z.array(zod.z.object({
+    key: zod.z.string(),
+    sha256: zod.z.string(),
+    bytes: zod.z.number()["int"]().nonnegative()
+  })).nullable().optional(),
+  /**
+   * The URL paths the live build serves from `public/`, as the loader has
+   * them -- without the bytes' hashes.
+   *
+   * The fallback for when `publicFiles` is `null`: a build content has no
+   * record of, which is every project cloned from a template seed. A publisher
+   * running on the site's own origin can fetch these and build with them;
+   * after that publish content holds their hashes and `publicFiles` answers.
+   * `null` when the loader serves no build or does not say.
+   */
+  publicPaths: zod.z.array(zod.z.string()).nullable().optional()
 });
 var parseBuildTarget = function parseBuildTarget(body) {
   return parse(buildTargetResponse, body, "GET /v1/build-target");

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

@@ -2599,6 +2599,34 @@ var Api = {
            * repository, and from a server that predates it.
            */
           sourceFiles: z.record(z.string(), z.string().nullable()).optional(),
+          /**
+           * The binary files this commit wrote -- an image uploaded in the
+           * Studio -- base64, by path, for a MANAGED project.
+           *
+           * The same reason as `sourceFiles`: the in-tab build publishes the
+           * site, and a file this commit added is in no earlier build. Local
+           * files only; a remote one is served from its own URL and was never
+           * part of a build. A deleted file is a `null` in `sourceFiles`, as
+           * it always was.
+           */
+          binaryFiles: z.record(z.string(), z.string()).optional(),
+          /**
+           * The branch this commit is on, for a MANAGED project -- the
+           * content service's word for it.
+           *
+           * The in-tab build has to name the branch it was made at, and its
+           * only other source is the `val.server.ts` the last build was
+           * wired with: a project cloned from a template seed has one wired
+           * at no commit, so without this its first publish is branchless
+           * and the loader refuses it.
+           */
+          branch: z.string().optional(),
+          /**
+           * Binary files this commit wrote whose bytes the server could not
+           * read back before committing. Named so the Studio refuses to build
+           * a site that would 404 them, rather than publishing it.
+           */
+          binaryFilesUnread: z.array(z.string()).optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -7224,7 +7252,37 @@ var buildTargetResponse = z.object({
  * "there is nothing here yet".
  */
 var projectSourceResponse = z.object({
-  files: z.record(z.string(), z.string()).nullable()
+  files: z.record(z.string(), z.string()).nullable(),
+  /**
+   * The live build's `public/*` artifacts, by hash -- what a publisher with no
+   * checkout carries into its build so the site keeps its favicon and images.
+   *
+   * The loader stores public files PER BUILD, so a build that names none
+   * serves none. A publisher with a checkout has them on disk; the Studio has
+   * this. Re-declaring one costs nothing: content holds the bytes for the
+   * project already and asks for no upload.
+   *
+   * `null` when content cannot say -- the live build was not published through
+   * it -- and absent from a content service that predates it. A publisher
+   * must treat both as "unknown", never as "none": publishing on that guess
+   * deletes every public file the site has.
+   */
+  publicFiles: z.array(z.object({
+    key: z.string(),
+    sha256: z.string(),
+    bytes: z.number()["int"]().nonnegative()
+  })).nullable().optional(),
+  /**
+   * The URL paths the live build serves from `public/`, as the loader has
+   * them -- without the bytes' hashes.
+   *
+   * The fallback for when `publicFiles` is `null`: a build content has no
+   * record of, which is every project cloned from a template seed. A publisher
+   * running on the site's own origin can fetch these and build with them;
+   * after that publish content holds their hashes and `publicFiles` answers.
+   * `null` when the loader serves no build or does not say.
+   */
+  publicPaths: z.array(z.string()).nullable().optional()
 });
 var parseBuildTarget = function parseBuildTarget(body) {
   return parse(buildTargetResponse, body, "GET /v1/build-target");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/shared",
-  "version": "0.136.1",
+  "version": "0.136.2",
   "private": false,
   "description": "Val shared types and utilities",
   "repository": {