@valbuild/shared 0.136.10 → 0.138.0

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

@@ -1503,6 +1503,28 @@ var GenericError = zod.z.object({
   message: zod.z.string()
 });
 
+/**
+ * What answered when one URL was opened.
+ *
+ * The one place the Studio's `ExternalUrlProbeResult` and the server's
+ * `ProbeResult` meet, so the two cannot drift without this failing to parse.
+ */
+var ExternalUrlProbeResult = zod.z.union([zod.z.object({
+  kind: zod.z.literal("answered"),
+  code: zod.z.number(),
+  finalUrl: zod.z.string(),
+  ms: zod.z.number()
+}), zod.z.object({
+  kind: zod.z.literal("unreachable"),
+  message: zod.z.string()
+}), zod.z.object({
+  kind: zod.z.literal("timeout"),
+  ms: zod.z.number()
+}), zod.z.object({
+  kind: zod.z.literal("skipped"),
+  message: zod.z.string()
+})]);
+
 /**
  * Why a publish cannot happen, in a form the Studio can show.
  *
@@ -1941,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"),
@@ -1991,6 +2020,13 @@ var Api = {
            * content service that predates it sends nothing.
            */
           headPatchId: PatchId.nullable().optional(),
+          /**
+           * The version of the chain `headPatchId` was read at, bumped by
+           * every write and delete. `/stat` has more than one caller, so
+           * answers can land out of order; a client keeps the head with the
+           * highest version. Optional, for the same reason `headPatchId` is.
+           */
+          headVersion: zod.z.number().optional(),
           commits: zod.z.array(ValCommit),
           /**
            * The publishes the content service knows about.
@@ -2031,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()
         })])
       })])
@@ -2144,6 +2187,42 @@ var Api = {
       })])
     }
   },
+  /**
+   * Open a batch of external URLs and report what answered.
+   *
+   * A batch rather than one URL because the client checks a list, and a POST
+   * rather than a GET because the list is the input and does not belong in a
+   * URL or a cache.
+   *
+   * The server makes outbound requests to addresses this body supplies, which
+   * is SSRF by construction - see `linkCheck/addressGuard.ts` for the deny
+   * list that makes it safe, and `docs/plans/external-page-link-checks.md` for
+   * why it is a deny list on the RESOLVED address.
+   */
+  "/external-urls/check": {
+    POST: {
+      req: {
+        body: zod.z.object({
+          /*
+           * Capped, and the cap is the point rather than a formality: each URL
+           * is an outbound connection, and a body is not allowed to ask this
+           * server to open a thousand of them. The client sends ten at a time.
+           */
+          urls: zod.z.array(zod.z.string()).min(1).max(20)
+        }),
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          /** Keyed by the URL exactly as it was asked about. */
+          results: zod.z.record(zod.z.string(), ExternalUrlProbeResult)
+        })
+      })])
+    }
+  },
   "/direct-file-upload-settings": {
     POST: {
       req: {
@@ -2195,7 +2274,14 @@ var Api = {
            * groups, and a client that predates this is deleting correctly,
            * just not repairing.
            */
-          unstagePatchIds: zod.z.array(PatchId).optional()
+          unstagePatchIds: zod.z.array(PatchId).optional(),
+          /*
+           * Answer with `{ deleted, headVersion }` rather than the bare id
+           * array. Asked for rather than always sent, because the array is
+           * what a Studio bundle from before this parses — and a tab left
+           * open across a deploy still runs one.
+           */
+          reportHeadVersion: zod.z.literal(true).optional()
         }).optional(),
         cookies: {
           val_session: zod.z.string().optional()
@@ -2209,7 +2295,16 @@ var Api = {
         })
       }), zod.z.object({
         status: zod.z.literal(200),
-        json: zod.z.array(PatchId)
+        json: zod.z.union([zod.z.array(PatchId), zod.z.object({
+          deleted: zod.z.array(PatchId),
+          /**
+           * The chain version this delete moved the branch to. Absent when
+           * it moved nothing, or the content service does not version its
+           * chain. Compared with `headVersion` on `/stat`: an answer read
+           * before the delete would put the deleted head back.
+           */
+          headVersion: zod.z.number().optional()
+        })])
       })])
     },
     PUT: {
@@ -2257,7 +2352,14 @@ var Api = {
         json: zod.z.object({
           newPatchIds: zod.z.array(PatchId),
           parentRef: ParentRef,
-          patchGroupId: zod.z.string().optional()
+          patchGroupId: zod.z.string().optional(),
+          /**
+           * The chain version the last of these patches made, comparable with
+           * `headVersion` on `/stat`. A client keeps the highest version, so a
+           * stat read before this write does not put its parent back behind
+           * it. Absent in `fs` mode and from an older content service.
+           */
+          headVersion: zod.z.number().optional()
         })
       })])
     },
@@ -2513,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()
         })
       })])
     }
@@ -2692,7 +2804,14 @@ var Api = {
             patchId: PatchId,
             moduleFilePath: ModuleFilePath,
             message: zod.z.string()
-          })).optional()
+          })).optional(),
+          /**
+           * The chain version this publish moved the branch to, where the
+           * content service versions its chain and the publish applied
+           * anything. See `headVersion` on `/stat`: a `/stat` answer read
+           * before the publish would put its patches back to pending.
+           */
+          headVersion: zod.z.number().optional()
         })
       }),
       /*
@@ -7365,6 +7484,54 @@ var projectSourceResponse = zod.z.object({
    */
   publicPaths: zod.z.array(zod.z.string()).nullable().optional()
 });
+/**
+ * Whether a managed project can be updated onto its template's current seed,
+ * and -- when it is asked with `POST`, the press -- what to build against.
+ *
+ * An update rebuilds the site as it is on newer dependencies. The loader
+ * decides whether there is one; content adds whether the project is managed at
+ * all, and the branch head the rebuild is wired at, because an update
+ * publishes no content of its own.
+ *
+ * `target` is a `/build-target` answer whose project half is the SEED's
+ * dependency layer, already copied into the project so a publish can name it.
+ * Only a `POST` carries it.
+ */
+var dependencyChange = zod.z.object({
+  name: zod.z.string(),
+  section: zod.z["enum"](["dependencies", "devDependencies"]),
+  /** `null` for a dependency the template added. */
+  from: zod.z.string().nullable(),
+  /** `null` for a dependency the template dropped: it leaves `package.json`. */
+  to: zod.z.string().nullable()
+});
+var updateTargetResponse = zod.z.discriminatedUnion("status", [zod.z.object({
+  status: zod.z.literal("current"),
+  template: zod.z.string(),
+  layerRev: zod.z.string()
+}), zod.z.object({
+  status: zod.z.literal("available"),
+  template: zod.z.string(),
+  /** Empty when only the dependency layer moved, and no version did. */
+  changes: zod.z.array(dependencyChange),
+  layerRev: zod.z.object({
+    from: zod.z.string().nullable(),
+    to: zod.z.string()
+  }),
+  /** The project's `package.json`, rewritten to the seed's versions. */
+  packageJson: zod.z.string(),
+  /** The branch head to build at; `null` for a project with no commits. */
+  commit: zod.z.string().nullable(),
+  branch: zod.z.string(),
+  target: buildTargetResponse.optional()
+}), zod.z.object({
+  status: zod.z.literal("unavailable"),
+  reason: zod.z.string(),
+  message: zod.z.string()
+})]);
+var parseUpdateTarget = function parseUpdateTarget(body) {
+  return parse(updateTargetResponse, body, "/v1/update-target");
+};
 var parseBuildTarget = function parseBuildTarget(body) {
   return parse(buildTargetResponse, body, "GET /v1/build-target");
 };
@@ -7372,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.
  *
@@ -7528,12 +7777,20 @@ 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;
 exports.partitionValidationErrors = partitionValidationErrors;
 exports.performSearch = performSearch;