@valbuild/shared 0.136.1 → 0.136.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @valbuild/shared
 
+## 0.136.3
+
+### Patch Changes
+
+- [#726](https://github.com/valbuild/val/pull/726) [`3b19534`](https://github.com/valbuild/val/commit/3b19534bb7aa16452a104906d9594083c3bc3e89) Thanks [@freekh](https://github.com/freekh)! - A Studio publish of a project with no repository now ships every edit that was saved, and keeps the site styled.
+
+  - A host that embeds the project's source can hand it to Val as `projectSource` (`initValServer(..., { http: { projectSource } })`). A publish then patches that text, not text fetched from the content service at a commit, which a project with no repository does not have. The build platform's wiring passes the build's own source, so `.val.ts` can be rendered for a project made on `/new`. Before, its first save produced no files, and the build that followed carried none of the save's edits.
+  - New route `GET /api/val/built-source`: the `.val.ts` text of every module changed since the running build, with every commit since it applied. The Studio builds from it, so an edit whose own publish failed, and a Finish publishing, are no longer left out of the next build.
+  - A Studio build that compiles no stylesheet (a browser cannot run Tailwind `@plugin`s) keeps the live site's. A Studio save never changes a stylesheet or a component, so the live CSS is still the right one.
+
+## 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

@@ -1022,6 +1022,51 @@ export declare const Api: {
             }, z.core.$strip>]>;
         };
     };
+    /**
+     * The `.val.ts` text of every module that changed since the RUNNING build,
+     * with every commit since it applied, for a build made in the browser.
+     *
+     * A Studio build starts from the source stored with the live build. A commit
+     * whose own publish failed -- or the first commit of a project that started
+     * as a copy of a template -- is in content and in no stored source, so a build
+     * that added only its own save's files shipped without it. Only this server
+     * can render those commits back into text: content keeps a managed project's
+     * content as Source, not as files.
+     *
+     * Committed patches only. A pending one is somebody's unpublished work, and
+     * is not this build's to ship. 409 where there is nothing to answer with: a
+     * project with a repository, or a build that did not embed its source.
+     */
+    "/built-source": {
+        GET: {
+            req: {
+                cookies: {
+                    val_session: z.ZodOptional<z.ZodString>;
+                };
+            };
+            res: z.ZodUnion<readonly [z.ZodObject<{
+                status: z.ZodLiteral<401>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<409>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<500>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<200>;
+                json: z.ZodObject<{
+                    files: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>;
+        };
+    };
     "/profiles": {
         GET: {
             req: {
@@ -1077,6 +1122,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

@@ -2506,6 +2506,43 @@ var Api = {
       })])
     }
   },
+  /**
+   * The `.val.ts` text of every module that changed since the RUNNING build,
+   * with every commit since it applied, for a build made in the browser.
+   *
+   * A Studio build starts from the source stored with the live build. A commit
+   * whose own publish failed -- or the first commit of a project that started
+   * as a copy of a template -- is in content and in no stored source, so a build
+   * that added only its own save's files shipped without it. Only this server
+   * can render those commits back into text: content keeps a managed project's
+   * content as Source, not as files.
+   *
+   * Committed patches only. A pending one is somebody's unpublished work, and
+   * is not this build's to ship. 409 where there is nothing to answer with: a
+   * project with a repository, or a build that did not embed its source.
+   */
+  "/built-source": {
+    GET: {
+      req: {
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(409),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          /** By path, as `/save`'s `sourceFiles`. `null` is a deleted file. */
+          files: zod.z.record(zod.z.string(), zod.z.string().nullable())
+        })
+      })])
+    }
+  },
   "/profiles": {
     GET: {
       req: {
@@ -2606,6 +2643,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 +7296,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

@@ -2506,6 +2506,43 @@ var Api = {
       })])
     }
   },
+  /**
+   * The `.val.ts` text of every module that changed since the RUNNING build,
+   * with every commit since it applied, for a build made in the browser.
+   *
+   * A Studio build starts from the source stored with the live build. A commit
+   * whose own publish failed -- or the first commit of a project that started
+   * as a copy of a template -- is in content and in no stored source, so a build
+   * that added only its own save's files shipped without it. Only this server
+   * can render those commits back into text: content keeps a managed project's
+   * content as Source, not as files.
+   *
+   * Committed patches only. A pending one is somebody's unpublished work, and
+   * is not this build's to ship. 409 where there is nothing to answer with: a
+   * project with a repository, or a build that did not embed its source.
+   */
+  "/built-source": {
+    GET: {
+      req: {
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(409),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          /** By path, as `/save`'s `sourceFiles`. `null` is a deleted file. */
+          files: zod.z.record(zod.z.string(), zod.z.string().nullable())
+        })
+      })])
+    }
+  },
   "/profiles": {
     GET: {
       req: {
@@ -2606,6 +2643,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 +7296,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

@@ -2499,6 +2499,43 @@ var Api = {
       })])
     }
   },
+  /**
+   * The `.val.ts` text of every module that changed since the RUNNING build,
+   * with every commit since it applied, for a build made in the browser.
+   *
+   * A Studio build starts from the source stored with the live build. A commit
+   * whose own publish failed -- or the first commit of a project that started
+   * as a copy of a template -- is in content and in no stored source, so a build
+   * that added only its own save's files shipped without it. Only this server
+   * can render those commits back into text: content keeps a managed project's
+   * content as Source, not as files.
+   *
+   * Committed patches only. A pending one is somebody's unpublished work, and
+   * is not this build's to ship. 409 where there is nothing to answer with: a
+   * project with a repository, or a build that did not embed its source.
+   */
+  "/built-source": {
+    GET: {
+      req: {
+        cookies: {
+          val_session: z.string().optional()
+        }
+      },
+      res: z.union([unauthorizedResponse, z.object({
+        status: z.literal(409),
+        json: GenericError
+      }), z.object({
+        status: z.literal(500),
+        json: GenericError
+      }), z.object({
+        status: z.literal(200),
+        json: z.object({
+          /** By path, as `/save`'s `sourceFiles`. `null` is a deleted file. */
+          files: z.record(z.string(), z.string().nullable())
+        })
+      })])
+    }
+  },
   "/profiles": {
     GET: {
       req: {
@@ -2599,6 +2636,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 +7289,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.3",
   "private": false,
   "description": "Val shared types and utilities",
   "repository": {