@valbuild/shared 0.137.0 → 0.138.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @valbuild/shared
 
+## 0.138.0
+
+### Minor Changes
+
+- [#754](https://github.com/valbuild/val/pull/754) [`6216172`](https://github.com/valbuild/val/commit/62161729aa40f737590b0a8093c0394385fffd8d) Thanks [@freekh](https://github.com/freekh)! - Connected projects hosted on the Val platform publish as a queued job too.
+
+  For a project with a GitHub repository whose site runs on the Val platform, pressing **Publish** is now a request, just as it is for a managed project. The Studio sends the job's changes; the content service pushes them as one commit on top of whatever is on the branch at that moment, so a developer's code push in between is kept. CI then builds it. A developer's change to the site's content files that this deployment has not seen stops the publish before anything is pushed, and says so.
+
+  - A build that CI reports as failed shows "Published, not on the site yet", with **View run**. The next publish builds again.
+  - New CLI command, `val ci-report --status failed|succeeded`, for a workflow's last step. It reads the commit, the branch and the run's address from GitHub Actions, uses the same `VAL_PROJECT_TOKEN` as `val publish`, and never fails the job.
+
+  Connected projects on a host of their own (for example Vercel) publish exactly as before.
+
+- [#754](https://github.com/valbuild/val/pull/754) [`40e933d`](https://github.com/valbuild/val/commit/40e933da7fe01cfe1c3f4a43c156f0b2f8a11f62) Thanks [@freekh](https://github.com/freekh)! - Publishing a managed project is now a queued job, and a publish is either live or it did not happen.
+
+  Pressing **Publish** in a managed project no longer commits first and builds after. It asks the content service for a publish job and returns at once; the Studio tab that pressed builds the job and uploads it, and the content service checks the build renders and makes it live — recording the commit only then. So there is no longer a "Saved, not yet live" state to get stuck in, and no **Finish publishing** button to get out of it.
+
+  - A press made while another publish is going out is queued behind it, and built when its turn comes by whichever open Studio tab is free.
+  - A tab that closes after uploading costs nothing: the rest of the publish is the content service's.
+  - A publish that fails before it goes live says so, with **Try again** and **Discard changes**. Your changes are kept either way.
+  - Publishing from the site (a page that cannot build) still opens a Studio window to build it; the window now runs the publish job for the page.
+
+  Connected projects (with a repository) that are hosted on the Val platform publish as a queued job too — see the note on connected projects. Those hosted elsewhere, for example on Vercel, publish exactly as before.
+
+  For the Val server: the publish proxy now forwards the publish-job routes, `/api/val/publish-job-prepare` renders a job's sources and hands content its archive, and `/api/val/built-source` is removed.
+
+### Patch Changes
+
+- Updated dependencies [[`57af895`](https://github.com/valbuild/val/commit/57af8959cc46519a405b1ed7441623f8bf2e6d27), [`5876fe0`](https://github.com/valbuild/val/commit/5876fe075fdee1f76f1cdaa2488ac52c58c894a8)]:
+  - @valbuild/core@0.138.0
+
 ## 0.137.0
 
 ### Minor Changes

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

@@ -424,6 +424,7 @@ export declare const Api: {
                     mode: z.ZodUnion<readonly [z.ZodLiteral<"http">, z.ZodLiteral<"fs">]>;
                     jsonEntriesSha: z.ZodOptional<z.ZodString>;
                     sourceMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"managed">, z.ZodLiteral<"connected">]>>;
+                    publishJobs: z.ZodOptional<z.ZodBoolean>;
                     publishRefusal: z.ZodOptional<z.ZodObject<{
                         code: z.ZodLiteral<"no-base">;
                         message: z.ZodString;
@@ -470,6 +471,7 @@ export declare const Api: {
                     profileId: z.ZodNullable<z.ZodString>;
                     mode: z.ZodUnion<readonly [z.ZodLiteral<"http">, z.ZodLiteral<"fs">]>;
                     sourceMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"managed">, z.ZodLiteral<"connected">]>>;
+                    publishJobs: z.ZodOptional<z.ZodBoolean>;
                     publishRefusal: z.ZodOptional<z.ZodObject<{
                         code: z.ZodLiteral<"no-base">;
                         message: z.ZodString;
@@ -1078,24 +1080,14 @@ 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: {
+    "/publish-job-prepare": {
+        POST: {
             req: {
+                body: z.ZodObject<{
+                    jobId: z.ZodString;
+                    tab: z.ZodString;
+                    patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
+                }, z.core.$strip>;
                 cookies: {
                     val_session: z.ZodOptional<z.ZodString>;
                 };
@@ -1105,6 +1097,11 @@ export declare const Api: {
                 json: z.ZodObject<{
                     message: z.ZodString;
                 }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<400>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<409>;
                 json: z.ZodObject<{
@@ -1115,10 +1112,28 @@ export declare const Api: {
                 json: z.ZodObject<{
                     message: z.ZodString;
                 }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<502>;
+                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>>;
+                    job: z.ZodNullable<z.ZodObject<{
+                        id: z.ZodString;
+                        step: z.ZodNullable<z.ZodEnum<{
+                            prepare: "prepare";
+                            build: "build";
+                            upload: "upload";
+                        }>>;
+                        base: z.ZodNullable<z.ZodString>;
+                        patches: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>>;
+                    sourceFiles: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+                    binaryFiles: z.ZodRecord<z.ZodString, z.ZodString>;
+                    binaryFilesUnread: z.ZodArray<z.ZodString>;
+                    branch: z.ZodNullable<z.ZodString>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>;
         };

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

@@ -1,10 +1,12 @@
 /**
  * The publish API's types, COPIED from the service that serves them.
  *
- * Source: `content/src/handlers/Api.ts` in valbuild/home, branch
- * `claude/new-project-studio-saves-0g9ksb`, commit `ecf3b8d`. The routes below
- * are that file's `/publish*` entries and the two types they use, verbatim,
- * comments included, so that the two can be diffed by eye.
+ * Source: `content/src/handlers/Api.ts` in valbuild/home. The routes below
+ * are that file's `/publish*` entries and the types they use, verbatim,
+ * comments included, so that the two can be diffed by eye: the publish
+ * lifecycle from branch `claude/new-project-studio-saves-0g9ksb`, commit
+ * `ecf3b8d`; the publish-job routes (`/publish-requests`, `/publish-jobs`)
+ * and `PublishRequestStatus` / `PublishTabJob` from `main`, commit `acb4a49`, with `/ci-runs`.
  *
  * **Copied rather than imported, because it cannot be imported.** That file
  * lives in a private repository which publishes nothing to npm, and its own
@@ -23,6 +25,7 @@
  * A copy is not a guarantee, only a tripwire: nothing checks it against the
  * service, and the parsers in `protocol.ts` are what actually holds at runtime.
  */
+import type { Json } from "@valbuild/core";
 export type ContentPublishApi = {
     /**
      * Publishing a build, as a resource with a lifecycle.
@@ -175,6 +178,173 @@ export type ContentPublishApi = {
             };
         };
     };
+    /**
+     * Publishing as a queued job: a press of Publish is a REQUEST, and returns
+     * at once. A job takes every queued request and everything pending; the tab
+     * that pressed runs its prepare (through the Val server), build and upload,
+     * reporting each step; then content runs verify and the seal itself. See
+     * docs/app-mode.md, "Publishing is a queued job".
+     *
+     * ```
+     * POST /publish-requests             press    -> the request, and a job to build
+     * GET  /publish-requests/{id}        where it is: queued, publishing, live, failed
+     * POST /publish-requests/try-again   Try again: resume a paused queue, press anew
+     * POST /publish-jobs/next            a free tab asks for queued work
+     * POST /publish-jobs/{id}/prepare    the job's sources, archived (the Val server's)
+     * POST /publish-jobs/{id}/steps      the tab reports build and upload
+     * POST /publish-jobs/{id}/renew      the tab is still building
+     * POST /publish-jobs/{id}/cancel     Cancel, before the seal
+     * POST /publish-jobs/{id}/discard    Discard these changes, on a failed job
+     * ```
+     *
+     * Every id the Studio sends -- a request's, a tab's -- is its own, minted by
+     * it, `[A-Za-z0-9_-]{1,100}`. A press is idempotent on its request id; a step
+     * report names its step, so one retried after a lost answer does nothing
+     * twice.
+     */
+    /**
+     * CI's own report of how a build of a git commit went, sent by the
+     * connected workflow's last step with its project token. See `ciRuns.ts`.
+     */
+    "/ci-runs": {
+        POST: {
+            body: {
+                commit: string;
+                branch?: string;
+                status: "failed" | "succeeded";
+                url?: string;
+            };
+            res: {
+                recorded: true;
+            };
+        };
+    };
+    "/ci-runs/newest": {
+        GET: {
+            res: {
+                run: {
+                    commit: string;
+                    status: "failed" | "succeeded";
+                    url: string | null;
+                } | null;
+            };
+        };
+    };
+    "/publish-requests": {
+        POST: {
+            body: {
+                requestId: string;
+                tab: string;
+            };
+            res: {
+                request: PublishRequestStatus;
+                job: PublishTabJob | null;
+            };
+        };
+    };
+    "/publish-requests/try-again": {
+        POST: {
+            body: {
+                requestId: string;
+                tab: string;
+            };
+            res: {
+                request: PublishRequestStatus;
+                job: PublishTabJob | null;
+            };
+        };
+    };
+    "/publish-requests/:requestId": {
+        GET: {
+            res: {
+                request: PublishRequestStatus;
+            };
+        };
+    };
+    "/publish-jobs/next": {
+        POST: {
+            body: {
+                tab: string;
+            };
+            res: {
+                job: PublishTabJob | null;
+            };
+        };
+    };
+    "/publish-jobs/:jobId/prepare": {
+        POST: {
+            /**
+             * `/commit`'s body, less what names a commit: the job's commit is minted
+             * at the seal. `modules` is required here -- a managed commit's archive,
+             * written from it, is the only copy of what it published.
+             */
+            body: {
+                tab: string;
+                root: string;
+                filesDirectory?: string;
+                patchedSourceFiles: Record<string, string | null>;
+                patchedBinaryFilesDescriptors: Record<string, {
+                    patchId: string;
+                    remote?: boolean;
+                }>;
+                modules: Record<string, {
+                    source: Json;
+                    schema: Json;
+                }>;
+                /**
+                 * Connected: the git commit the Studio's deployment was built from. A
+                 * branch whose tip is that commit has nothing it has not seen.
+                 */
+                gitCommit?: string;
+            };
+            res: {
+                job: PublishTabJob | null;
+            };
+        };
+    };
+    "/publish-jobs/:jobId/steps": {
+        POST: {
+            body: {
+                tab: string;
+                step: "prepare" | "build" | "upload";
+                ok: boolean;
+                /** A finished build step: the id of the publish (`POST /publish`) it declared. */
+                build?: string;
+            };
+            res: {
+                job: PublishTabJob | null;
+            };
+        };
+    };
+    "/publish-jobs/:jobId/renew": {
+        POST: {
+            body: {
+                tab: string;
+            };
+            res: {
+                renewed: boolean;
+            };
+        };
+    };
+    "/publish-jobs/:jobId/cancel": {
+        POST: {
+            res: {
+                cancelled: boolean;
+            };
+        };
+    };
+    "/publish-jobs/:jobId/discard": {
+        POST: {
+            /** The forward closure, as `DELETE /patches` takes it. */
+            body: {
+                unstagePatchIds?: string[];
+            };
+            /** Changes it could not discard: another job in flight holds them. */
+            res: {
+                stillHeld: string[];
+            };
+        };
+    };
 };
 /**
  * Where a publish is. Mirrors `PublishState` in `utils/publishPlan.ts`, which
@@ -199,3 +369,36 @@ export type PublishProblem = {
     hint?: string;
     keys?: string[];
 };
+/**
+ * Where a press of Publish is. `live` names the commit that carries it -- its
+ * own, or a newer one that contains it; `failed` names what the editor can do.
+ * The same shape as `RequestStatus` in `utils/jobPlan.ts`, which decides it.
+ */
+export type PublishRequestStatus = {
+    kind: "queued";
+} | {
+    kind: "publishing";
+} | {
+    kind: "live";
+    commit: string;
+} | {
+    kind: "failed";
+    message: string;
+    actions: ("try-again" | "discard" | "re-run-build")[];
+    /** The job that failed: what Discard is pressed on. */
+    job: string;
+} | {
+    kind: "cancelled";
+} | {
+    kind: "nothing-to-publish";
+};
+/** What a tab needs to know about a job it is running. */
+export type PublishTabJob = {
+    id: string;
+    /** The step the tab is to run next; null once the job is content's. */
+    step: "prepare" | "build" | "upload" | null;
+    /** The recorded commit its build is based on. */
+    base: string | null;
+    /** The changes its build is to include, on top of `base`. */
+    patches: string[];
+};

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ContentPublishApi, PublishProblem, PublishState } from "./contentApi.js";
+import { ContentPublishApi, PublishProblem, PublishRequestStatus, PublishState, PublishTabJob } from "./contentApi.js";
 /**
  * Reading what content answers.
  *
@@ -195,6 +195,25 @@ export type DependencyChange = z.infer<typeof dependencyChange>;
 export declare const parseUpdateTarget: (body: unknown) => UpdateTargetResponse;
 export declare const parseBuildTarget: (body: unknown) => BuildTargetResponse;
 export declare const parseProjectSource: (body: unknown) => ProjectSourceResponse;
+export type { PublishRequestStatus, PublishTabJob };
+export type PressResponse = ContentPublishApi["/publish-requests"]["POST"]["res"];
+export type RequestStatusResponse = ContentPublishApi["/publish-requests/:requestId"]["GET"]["res"];
+export type NextJobResponse = ContentPublishApi["/publish-jobs/next"]["POST"]["res"];
+export type JobPrepareBody = ContentPublishApi["/publish-jobs/:jobId/prepare"]["POST"]["body"];
+export type JobStepBody = ContentPublishApi["/publish-jobs/:jobId/steps"]["POST"]["body"];
+export type JobStepResponse = ContentPublishApi["/publish-jobs/:jobId/steps"]["POST"]["res"];
+export type JobRenewResponse = ContentPublishApi["/publish-jobs/:jobId/renew"]["POST"]["res"];
+export type JobCancelResponse = ContentPublishApi["/publish-jobs/:jobId/cancel"]["POST"]["res"];
+export type JobDiscardResponse = ContentPublishApi["/publish-jobs/:jobId/discard"]["POST"]["res"];
+export declare const parsePress: (body: unknown, call: string) => PressResponse;
+export declare const parseRequestStatus: (body: unknown) => RequestStatusResponse;
+export declare const parseJob: (body: unknown, call: string) => JobStepResponse;
+export declare const parseRenew: (body: unknown) => JobRenewResponse;
+export declare const parseCancel: (body: unknown) => JobCancelResponse;
+export declare const parseDiscard: (body: unknown) => JobDiscardResponse;
+export type CiRunReportBody = ContentPublishApi["/ci-runs"]["POST"]["body"];
+export type NewestCiRunResponse = ContentPublishApi["/ci-runs/newest"]["GET"]["res"];
+export declare const parseNewestCiRun: (body: unknown) => NewestCiRunResponse;
 /**
  * The `details` of a refusal, when it carries a list of problems.
  *

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

@@ -1963,6 +1963,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: zod.z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         }), zod.z.object({
           type: zod.z.literal("use-websocket"),
@@ -2060,6 +2067,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: zod.z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         })])
       })])
@@ -2601,39 +2615,49 @@ 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: {
+  "/publish-job-prepare": {
+    POST: {
       req: {
+        body: zod.z.object({
+          jobId: zod.z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          tab: zod.z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          /** The job's changes, as content handed them to the tab. */
+          patchIds: zod.z.array(PatchId)
+        }),
         cookies: {
           val_session: zod.z.string().optional()
         }
       },
       res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError
+      }), 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(502),
+        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())
+          /** The job as content has it now: its next step is the build. */
+          job: zod.z.object({
+            id: zod.z.string(),
+            step: zod.z["enum"](["prepare", "build", "upload"]).nullable(),
+            base: zod.z.string().nullable(),
+            patches: zod.z.array(zod.z.string())
+          }).nullable(),
+          /** Every source file of the job's content, by path. `null` is deleted. */
+          sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()),
+          /** The job's own local binary files, base64, by path. */
+          binaryFiles: zod.z.record(zod.z.string(), zod.z.string()),
+          /** 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()
         })
       })])
     }
@@ -7515,6 +7539,88 @@ var parseProjectSource = function parseProjectSource(body) {
   return parse(projectSourceResponse, body, "GET /v1/project-source");
 };
 
+// ------------------------------------------------------ publish jobs
+
+/*
+ * Publishing as a queued job (valbuild/home docs/app-mode.md, "Publishing is a
+ * queued job"): a press is a request, the tab builds and uploads the job it is
+ * given, and content runs verify and the seal. Each parser is typed against
+ * the copy in `contentApi.ts`, so a copy brought up to date fails to compile
+ * here until these follow it.
+ */
+
+var requestStatus = zod.z.union([zod.z.object({
+  kind: zod.z.literal("queued")
+}), zod.z.object({
+  kind: zod.z.literal("publishing")
+}), zod.z.object({
+  kind: zod.z.literal("live"),
+  commit: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("failed"),
+  message: zod.z.string(),
+  actions: zod.z.array(zod.z["enum"](["try-again", "discard", "re-run-build"])),
+  job: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("cancelled")
+}), zod.z.object({
+  kind: zod.z.literal("nothing-to-publish")
+})]);
+var tabJob = zod.z.object({
+  id: zod.z.string(),
+  step: zod.z["enum"](["prepare", "build", "upload"]).nullable(),
+  base: zod.z.string().nullable(),
+  patches: zod.z.array(zod.z.string())
+});
+var pressResponse = zod.z.object({
+  request: requestStatus,
+  job: tabJob.nullable()
+});
+var requestStatusResponse = zod.z.object({
+  request: requestStatus
+});
+// `/next`, `/prepare` and `/steps` all answer with the job as it now is.
+var jobResponse = zod.z.object({
+  job: tabJob.nullable()
+});
+var renewResponse = zod.z.object({
+  renewed: zod.z["boolean"]()
+});
+var cancelResponse = zod.z.object({
+  cancelled: zod.z["boolean"]()
+});
+var discardResponse = zod.z.object({
+  stillHeld: zod.z.array(zod.z.string())
+});
+var parsePress = function parsePress(body, call) {
+  return parse(pressResponse, body, call);
+};
+var parseRequestStatus = function parseRequestStatus(body) {
+  return parse(requestStatusResponse, body, "GET /v1/publish-requests/{id}");
+};
+var parseJob = function parseJob(body, call) {
+  return parse(jobResponse, body, call);
+};
+var parseRenew = function parseRenew(body) {
+  return parse(renewResponse, body, "POST /v1/publish-jobs/{id}/renew");
+};
+var parseCancel = function parseCancel(body) {
+  return parse(cancelResponse, body, "POST /v1/publish-jobs/{id}/cancel");
+};
+var parseDiscard = function parseDiscard(body) {
+  return parse(discardResponse, body, "POST /v1/publish-jobs/{id}/discard");
+};
+var newestCiRunResponse = zod.z.object({
+  run: zod.z.object({
+    commit: zod.z.string(),
+    status: zod.z["enum"](["failed", "succeeded"]),
+    url: zod.z.string().nullable()
+  }).nullable()
+});
+var parseNewestCiRun = function parseNewestCiRun(body) {
+  return parse(newestCiRunResponse, body, "GET /v1/ci-runs/newest");
+};
+
 /**
  * The `details` of a refusal, when it carries a list of problems.
  *
@@ -7671,11 +7777,18 @@ exports.memoizePerRequest = memoizePerRequest;
 exports.newestCommitSha = newestCommitSha;
 exports.parseArtifacts = parseArtifacts;
 exports.parseBuildTarget = parseBuildTarget;
+exports.parseCancel = parseCancel;
 exports.parseDeclare = parseDeclare;
+exports.parseDiscard = parseDiscard;
+exports.parseJob = parseJob;
+exports.parseNewestCiRun = parseNewestCiRun;
+exports.parsePress = parsePress;
 exports.parseProblems = parseProblems;
 exports.parseProjectSource = parseProjectSource;
 exports.parsePromote = parsePromote;
 exports.parsePublishToken = parsePublishToken;
+exports.parseRenew = parseRenew;
+exports.parseRequestStatus = parseRequestStatus;
 exports.parseStatus = parseStatus;
 exports.parseUpdateTarget = parseUpdateTarget;
 exports.parseVerify = parseVerify;

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

@@ -1963,6 +1963,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: zod.z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         }), zod.z.object({
           type: zod.z.literal("use-websocket"),
@@ -2060,6 +2067,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: zod.z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         })])
       })])
@@ -2601,39 +2615,49 @@ 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: {
+  "/publish-job-prepare": {
+    POST: {
       req: {
+        body: zod.z.object({
+          jobId: zod.z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          tab: zod.z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          /** The job's changes, as content handed them to the tab. */
+          patchIds: zod.z.array(PatchId)
+        }),
         cookies: {
           val_session: zod.z.string().optional()
         }
       },
       res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(400),
+        json: GenericError
+      }), 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(502),
+        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())
+          /** The job as content has it now: its next step is the build. */
+          job: zod.z.object({
+            id: zod.z.string(),
+            step: zod.z["enum"](["prepare", "build", "upload"]).nullable(),
+            base: zod.z.string().nullable(),
+            patches: zod.z.array(zod.z.string())
+          }).nullable(),
+          /** Every source file of the job's content, by path. `null` is deleted. */
+          sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()),
+          /** The job's own local binary files, base64, by path. */
+          binaryFiles: zod.z.record(zod.z.string(), zod.z.string()),
+          /** 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()
         })
       })])
     }
@@ -7515,6 +7539,88 @@ var parseProjectSource = function parseProjectSource(body) {
   return parse(projectSourceResponse, body, "GET /v1/project-source");
 };
 
+// ------------------------------------------------------ publish jobs
+
+/*
+ * Publishing as a queued job (valbuild/home docs/app-mode.md, "Publishing is a
+ * queued job"): a press is a request, the tab builds and uploads the job it is
+ * given, and content runs verify and the seal. Each parser is typed against
+ * the copy in `contentApi.ts`, so a copy brought up to date fails to compile
+ * here until these follow it.
+ */
+
+var requestStatus = zod.z.union([zod.z.object({
+  kind: zod.z.literal("queued")
+}), zod.z.object({
+  kind: zod.z.literal("publishing")
+}), zod.z.object({
+  kind: zod.z.literal("live"),
+  commit: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("failed"),
+  message: zod.z.string(),
+  actions: zod.z.array(zod.z["enum"](["try-again", "discard", "re-run-build"])),
+  job: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("cancelled")
+}), zod.z.object({
+  kind: zod.z.literal("nothing-to-publish")
+})]);
+var tabJob = zod.z.object({
+  id: zod.z.string(),
+  step: zod.z["enum"](["prepare", "build", "upload"]).nullable(),
+  base: zod.z.string().nullable(),
+  patches: zod.z.array(zod.z.string())
+});
+var pressResponse = zod.z.object({
+  request: requestStatus,
+  job: tabJob.nullable()
+});
+var requestStatusResponse = zod.z.object({
+  request: requestStatus
+});
+// `/next`, `/prepare` and `/steps` all answer with the job as it now is.
+var jobResponse = zod.z.object({
+  job: tabJob.nullable()
+});
+var renewResponse = zod.z.object({
+  renewed: zod.z["boolean"]()
+});
+var cancelResponse = zod.z.object({
+  cancelled: zod.z["boolean"]()
+});
+var discardResponse = zod.z.object({
+  stillHeld: zod.z.array(zod.z.string())
+});
+var parsePress = function parsePress(body, call) {
+  return parse(pressResponse, body, call);
+};
+var parseRequestStatus = function parseRequestStatus(body) {
+  return parse(requestStatusResponse, body, "GET /v1/publish-requests/{id}");
+};
+var parseJob = function parseJob(body, call) {
+  return parse(jobResponse, body, call);
+};
+var parseRenew = function parseRenew(body) {
+  return parse(renewResponse, body, "POST /v1/publish-jobs/{id}/renew");
+};
+var parseCancel = function parseCancel(body) {
+  return parse(cancelResponse, body, "POST /v1/publish-jobs/{id}/cancel");
+};
+var parseDiscard = function parseDiscard(body) {
+  return parse(discardResponse, body, "POST /v1/publish-jobs/{id}/discard");
+};
+var newestCiRunResponse = zod.z.object({
+  run: zod.z.object({
+    commit: zod.z.string(),
+    status: zod.z["enum"](["failed", "succeeded"]),
+    url: zod.z.string().nullable()
+  }).nullable()
+});
+var parseNewestCiRun = function parseNewestCiRun(body) {
+  return parse(newestCiRunResponse, body, "GET /v1/ci-runs/newest");
+};
+
 /**
  * The `details` of a refusal, when it carries a list of problems.
  *
@@ -7671,11 +7777,18 @@ exports.memoizePerRequest = memoizePerRequest;
 exports.newestCommitSha = newestCommitSha;
 exports.parseArtifacts = parseArtifacts;
 exports.parseBuildTarget = parseBuildTarget;
+exports.parseCancel = parseCancel;
 exports.parseDeclare = parseDeclare;
+exports.parseDiscard = parseDiscard;
+exports.parseJob = parseJob;
+exports.parseNewestCiRun = parseNewestCiRun;
+exports.parsePress = parsePress;
 exports.parseProblems = parseProblems;
 exports.parseProjectSource = parseProjectSource;
 exports.parsePromote = parsePromote;
 exports.parsePublishToken = parsePublishToken;
+exports.parseRenew = parseRenew;
+exports.parseRequestStatus = parseRequestStatus;
 exports.parseStatus = parseStatus;
 exports.parseUpdateTarget = parseUpdateTarget;
 exports.parseVerify = parseVerify;

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

@@ -1956,6 +1956,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: z.union([z.literal("managed"), z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         }), z.object({
           type: z.literal("use-websocket"),
@@ -2053,6 +2060,13 @@ var Api = {
            * which is the one the Studio has always told.
            */
           sourceMode: z.union([z.literal("managed"), z.literal("connected")]).optional(),
+          /**
+           * A press of Publish is a publish JOB: every managed project,
+           * and a connected one hosted on the platform. Absent from a
+           * server that predates it: managed projects publish as jobs,
+           * connected ones by commit.
+           */
+          publishJobs: z["boolean"]().optional(),
           publishRefusal: PublishRefusal.optional()
         })])
       })])
@@ -2594,39 +2608,49 @@ 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: {
+  "/publish-job-prepare": {
+    POST: {
       req: {
+        body: z.object({
+          jobId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          tab: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+          /** The job's changes, as content handed them to the tab. */
+          patchIds: z.array(PatchId)
+        }),
         cookies: {
           val_session: z.string().optional()
         }
       },
       res: z.union([unauthorizedResponse, z.object({
+        status: z.literal(400),
+        json: GenericError
+      }), z.object({
         status: z.literal(409),
         json: GenericError
       }), z.object({
         status: z.literal(500),
         json: GenericError
+      }), z.object({
+        status: z.literal(502),
+        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())
+          /** The job as content has it now: its next step is the build. */
+          job: z.object({
+            id: z.string(),
+            step: z["enum"](["prepare", "build", "upload"]).nullable(),
+            base: z.string().nullable(),
+            patches: z.array(z.string())
+          }).nullable(),
+          /** Every source file of the job's content, by path. `null` is deleted. */
+          sourceFiles: z.record(z.string(), z.string().nullable()),
+          /** The job's own local binary files, base64, by path. */
+          binaryFiles: z.record(z.string(), z.string()),
+          /** Binary files whose bytes could not be read back. */
+          binaryFilesUnread: z.array(z.string()),
+          /** The branch the job publishes to. */
+          branch: z.string().nullable()
         })
       })])
     }
@@ -7508,6 +7532,88 @@ var parseProjectSource = function parseProjectSource(body) {
   return parse(projectSourceResponse, body, "GET /v1/project-source");
 };
 
+// ------------------------------------------------------ publish jobs
+
+/*
+ * Publishing as a queued job (valbuild/home docs/app-mode.md, "Publishing is a
+ * queued job"): a press is a request, the tab builds and uploads the job it is
+ * given, and content runs verify and the seal. Each parser is typed against
+ * the copy in `contentApi.ts`, so a copy brought up to date fails to compile
+ * here until these follow it.
+ */
+
+var requestStatus = z.union([z.object({
+  kind: z.literal("queued")
+}), z.object({
+  kind: z.literal("publishing")
+}), z.object({
+  kind: z.literal("live"),
+  commit: z.string()
+}), z.object({
+  kind: z.literal("failed"),
+  message: z.string(),
+  actions: z.array(z["enum"](["try-again", "discard", "re-run-build"])),
+  job: z.string()
+}), z.object({
+  kind: z.literal("cancelled")
+}), z.object({
+  kind: z.literal("nothing-to-publish")
+})]);
+var tabJob = z.object({
+  id: z.string(),
+  step: z["enum"](["prepare", "build", "upload"]).nullable(),
+  base: z.string().nullable(),
+  patches: z.array(z.string())
+});
+var pressResponse = z.object({
+  request: requestStatus,
+  job: tabJob.nullable()
+});
+var requestStatusResponse = z.object({
+  request: requestStatus
+});
+// `/next`, `/prepare` and `/steps` all answer with the job as it now is.
+var jobResponse = z.object({
+  job: tabJob.nullable()
+});
+var renewResponse = z.object({
+  renewed: z["boolean"]()
+});
+var cancelResponse = z.object({
+  cancelled: z["boolean"]()
+});
+var discardResponse = z.object({
+  stillHeld: z.array(z.string())
+});
+var parsePress = function parsePress(body, call) {
+  return parse(pressResponse, body, call);
+};
+var parseRequestStatus = function parseRequestStatus(body) {
+  return parse(requestStatusResponse, body, "GET /v1/publish-requests/{id}");
+};
+var parseJob = function parseJob(body, call) {
+  return parse(jobResponse, body, call);
+};
+var parseRenew = function parseRenew(body) {
+  return parse(renewResponse, body, "POST /v1/publish-jobs/{id}/renew");
+};
+var parseCancel = function parseCancel(body) {
+  return parse(cancelResponse, body, "POST /v1/publish-jobs/{id}/cancel");
+};
+var parseDiscard = function parseDiscard(body) {
+  return parse(discardResponse, body, "POST /v1/publish-jobs/{id}/discard");
+};
+var newestCiRunResponse = z.object({
+  run: z.object({
+    commit: z.string(),
+    status: z["enum"](["failed", "succeeded"]),
+    url: z.string().nullable()
+  }).nullable()
+});
+var parseNewestCiRun = function parseNewestCiRun(body) {
+  return parse(newestCiRunResponse, body, "GET /v1/ci-runs/newest");
+};
+
 /**
  * The `details` of a refusal, when it carries a list of problems.
  *
@@ -7529,4 +7635,4 @@ function parse(schema, body, call) {
   return parsed.data;
 }
 
-export { AA_LARGE, AA_TEXT, Api, BRAND_CONTRAST_PAIRS, BinaryFileRef, CodeOptions, ColorOptions, DEFAULT_ERROR_MESSAGE, DateOptions, ENCODE_DEFAULTS, ENCODE_MIME_TYPE_OF, FileOptions, HistoricalCommit, HistoricalModule, HistoricalPatchSet, HistoryError, ImageEncodeOption, ImageOptions, JSONValue, JSON_ENTRIES_BATCH_MAX, ModuleComparison, NEVER_ENCODED, ParentRef$1 as ParentRef, Patch, PatchBlock, PatchGroup, PatchId, PatchJSON, PublishProtocolError, RAMP_STEPS, RemirrorBr, RemirrorBulletList, RemirrorHeading, RemirrorImage, RemirrorJSON, RemirrorLinkMark, RemirrorListItem, RemirrorOrderedList, RemirrorParagraph, RemirrorText, RemirrorTextMark, RestoreVerdict, RichTextOptions, SCHEMA_SOURCE_FIXES, SerializedArraySchema, SerializedBooleanSchema, SerializedCodeSchema, SerializedColorSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedFileSchema, SerializedImageSchema, SerializedKeyOfSchema, SerializedLiteralSchema, SerializedLocaleSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedRecordSchema, SerializedRichTextSchema, SerializedRouteSchema, SerializedSchema, SerializedSettingsSchema, SerializedStringSchema, SerializedValViewSchema, SharedValConfig, VAL_ENABLE_COOKIE_NAME, VAL_GREEN_RAMP, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCommit, ValDeployment, accentRamp, buildDuplicatePatch, buildEmptyAtPathPatch, buildFileRefValue, buildImageGalleryPatch, buildRemoveImageGalleryEntryPatch, buildSearchIndex, chainHeadOf, checkCompatibility, chooseEncoded, concatModulePath, contrastRatio, createRegExpFromPattern, createSearchIndex, createValClient, declaredLocales, describeContainerAtPath, emptyOf, explainIncompatible, filterBlockingValidationErrors, filterRoutesByPatterns, findSimilar, fitWithin, flattenRichText, getErrorMessageFromUnknownJson, getFilenameFromRef, getInlineImgInfo, getKeyOfRecordAt, getRefParts, getRoutesOf, getRoutesWithModulePaths, getSourceAt, indexModule, isMimeTypeAccepted, isRemoteSchema, isSchemaSourceFixError, isSkippedSource, keyOfRecordPath, levenshtein, localeAt, memoizePerRequest, newestCommitSha, parseArtifacts, parseBuildTarget, parseDeclare, parseProblems, parseProjectSource, parsePromote, parsePublishToken, parseStatus, parseUpdateTarget, parseVerify, partitionValidationErrors, performSearch, relativeLuminance, remirrorToRichTextSource, removeModule, resolveEncodeSettings, resolvePairGround, resolveSchemaSourceFixForError, resolveSchemaSourceFixes, resolveSerializedSchemaAtPath, richTextToRemirror, safeParsePatch, sourcePathOfChild, themeCustomProperties, toolNames, traverseSchemaSource, urlOf, validateRoutePatterns, withExtension };
+export { AA_LARGE, AA_TEXT, Api, BRAND_CONTRAST_PAIRS, BinaryFileRef, CodeOptions, ColorOptions, DEFAULT_ERROR_MESSAGE, DateOptions, ENCODE_DEFAULTS, ENCODE_MIME_TYPE_OF, FileOptions, HistoricalCommit, HistoricalModule, HistoricalPatchSet, HistoryError, ImageEncodeOption, ImageOptions, JSONValue, JSON_ENTRIES_BATCH_MAX, ModuleComparison, NEVER_ENCODED, ParentRef$1 as ParentRef, Patch, PatchBlock, PatchGroup, PatchId, PatchJSON, PublishProtocolError, RAMP_STEPS, RemirrorBr, RemirrorBulletList, RemirrorHeading, RemirrorImage, RemirrorJSON, RemirrorLinkMark, RemirrorListItem, RemirrorOrderedList, RemirrorParagraph, RemirrorText, RemirrorTextMark, RestoreVerdict, RichTextOptions, SCHEMA_SOURCE_FIXES, SerializedArraySchema, SerializedBooleanSchema, SerializedCodeSchema, SerializedColorSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedFileSchema, SerializedImageSchema, SerializedKeyOfSchema, SerializedLiteralSchema, SerializedLocaleSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedRecordSchema, SerializedRichTextSchema, SerializedRouteSchema, SerializedSchema, SerializedSettingsSchema, SerializedStringSchema, SerializedValViewSchema, SharedValConfig, VAL_ENABLE_COOKIE_NAME, VAL_GREEN_RAMP, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCommit, ValDeployment, accentRamp, buildDuplicatePatch, buildEmptyAtPathPatch, buildFileRefValue, buildImageGalleryPatch, buildRemoveImageGalleryEntryPatch, buildSearchIndex, chainHeadOf, checkCompatibility, chooseEncoded, concatModulePath, contrastRatio, createRegExpFromPattern, createSearchIndex, createValClient, declaredLocales, describeContainerAtPath, emptyOf, explainIncompatible, filterBlockingValidationErrors, filterRoutesByPatterns, findSimilar, fitWithin, flattenRichText, getErrorMessageFromUnknownJson, getFilenameFromRef, getInlineImgInfo, getKeyOfRecordAt, getRefParts, getRoutesOf, getRoutesWithModulePaths, getSourceAt, indexModule, isMimeTypeAccepted, isRemoteSchema, isSchemaSourceFixError, isSkippedSource, keyOfRecordPath, levenshtein, localeAt, memoizePerRequest, newestCommitSha, parseArtifacts, parseBuildTarget, parseCancel, parseDeclare, parseDiscard, parseJob, parseNewestCiRun, parsePress, parseProblems, parseProjectSource, parsePromote, parsePublishToken, parseRenew, parseRequestStatus, parseStatus, parseUpdateTarget, parseVerify, partitionValidationErrors, performSearch, relativeLuminance, remirrorToRichTextSource, removeModule, resolveEncodeSettings, resolvePairGround, resolveSchemaSourceFixForError, resolveSchemaSourceFixes, resolveSerializedSchemaAtPath, richTextToRemirror, safeParsePatch, sourcePathOfChild, themeCustomProperties, toolNames, traverseSchemaSource, urlOf, validateRoutePatterns, withExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/shared",
-  "version": "0.137.0",
+  "version": "0.138.0",
   "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.137.0"
+    "@valbuild/core": "0.138.0"
   },
   "files": [
     "CHANGELOG.md",