@valbuild/shared 0.148.7 → 0.150.1

package/dist/protocol-1c13de0d.cjs.prod.js

@@ -0,0 +1,433 @@
+'use strict';
+
+var slicedToArray = require('./slicedToArray-af50e684.cjs.prod.js');
+var zod = require('zod');
+var zodValidationError = require('zod-validation-error');
+
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+
+/**
+ * Reading what content answers.
+ *
+ * Every type here comes from `contentApi.ts`, which is a copy of the
+ * service's own `Api.ts` - so the shapes are not re-derived from what this end
+ * wishes it received, and a copy brought up to date fails to compile wherever
+ * this CLI has not caught up.
+ *
+ * The schemas are the runtime half, and they are needed as well as the types:
+ * what arrives is JSON over HTTP from a service that versions separately, so a
+ * type alone asserts a shape rather than checking one. Each schema is
+ * annotated with the copied type it must produce (`z.ZodType<DeclareResponse>`
+ * and so on), which is what ties the two halves together - a schema that drifts
+ * from the copy does not compile, and an answer that drifts from the schema
+ * does not parse. `ValOpsHttp` in `@valbuild/server` reads every other content
+ * route the same way.
+ *
+ * Nothing here is laxer than the copy. An optional field is optional because
+ * the service says so; making a required one optional here would hide exactly
+ * the drift this file exists to catch.
+ */
+
+/** An artifact, as it is declared: by key, by hash, by size. */
+
+/** Permission to write one artifact's bytes to object storage. */
+
+var publishState = zod.z["enum"](["awaiting-artifacts", "ready", "verified", "live", "failed", "expired"]);
+var publishProblem = zod.z.object({
+  code: zod.z.string(),
+  message: zod.z.string(),
+  hint: zod.z.string().optional(),
+  keys: zod.z.array(zod.z.string()).optional()
+});
+var uploadSlot = zod.z.object({
+  key: zod.z.string(),
+  url: zod.z.string(),
+  method: zod.z.literal("PUT"),
+  headers: zod.z.record(zod.z.string(), zod.z.string()),
+  expiresAt: zod.z.string()
+});
+var declareResponse = zod.z.object({
+  publishId: zod.z.string(),
+  state: publishState,
+  project: zod.z.object({
+    publicProjectId: zod.z.string(),
+    siteUrl: zod.z.string().nullable()
+  }),
+  uploads: zod.z.array(uploadSlot),
+  have: zod.z.array(zod.z.string())
+});
+var artifactsResponse = zod.z.object({
+  state: publishState,
+  problems: zod.z.array(publishProblem)
+});
+var verifyResponse = zod.z.object({
+  state: publishState,
+  ok: zod.z["boolean"](),
+  previewUrl: zod.z.string().nullable(),
+  problems: zod.z.array(publishProblem)
+});
+var promoteResponse = zod.z.object({
+  state: publishState,
+  url: zod.z.string().nullable(),
+  commit: zod.z.string().nullable()
+});
+var statusResponse = zod.z.object({
+  publishId: zod.z.string(),
+  state: publishState,
+  buildHash: zod.z.string(),
+  missing: zod.z.array(zod.z.string()),
+  problems: zod.z.array(publishProblem)
+});
+var publishTokenResponse = zod.z.object({
+  token: zod.z.string(),
+  expiresAt: zod.z.string().nullable(),
+  publicProjectId: zod.z.string(),
+  productionUrl: zod.z.string().nullable()
+});
+
+/**
+ * Content answered, and the answer was not one this CLI can act on.
+ *
+ * Separate from a refusal, which is content saying no in a sentence meant for
+ * a person. This is two programs disagreeing - the copy in `contentApi.ts` and
+ * the service that has moved on from it - and the two want opposite things
+ * said about them.
+ */
+var PublishProtocolError = /*#__PURE__*/function (_Error) {
+  function PublishProtocolError(message) {
+    var _this;
+    slicedToArray._classCallCheck(this, PublishProtocolError);
+    _this = slicedToArray._callSuper(this, PublishProtocolError, [message]);
+    _this.name = "PublishProtocolError";
+    return _this;
+  }
+  slicedToArray._inherits(PublishProtocolError, _Error);
+  return slicedToArray._createClass(PublishProtocolError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+var parseDeclare = function parseDeclare(body) {
+  return parse(declareResponse, body, "POST /v1/publish");
+};
+var parseArtifacts = function parseArtifacts(body) {
+  return parse(artifactsResponse, body, "POST /v1/publish/{id}/artifacts");
+};
+var parseVerify = function parseVerify(body) {
+  return parse(verifyResponse, body, "POST /v1/publish/{id}/verify");
+};
+var parsePromote = function parsePromote(body) {
+  return parse(promoteResponse, body, "POST /v1/publish/{id}/promote");
+};
+var parseStatus = function parseStatus(body) {
+  return parse(statusResponse, body, "GET /v1/publish/{id}");
+};
+var parsePublishToken = function parsePublishToken(body, call) {
+  return parse(publishTokenResponse, body, call);
+};
+
+/**
+ * What a build targets, and the project's files, as the Studio asks for them.
+ *
+ * Both are read through `/publish-api` rather than fetched from the loader,
+ * because a browser has neither the loader's address nor a credential it would
+ * accept. `fetchBuildTarget` in `@valbuild/tanstack-build` is the other half --
+ * same shape, a different caller, and it CASTS where this parses.
+ *
+ * Parsed rather than cast here because of what sits in between: a proxy, a
+ * gateway and a service boundary. An HTML error page cast to `BuildTarget`
+ * fails several layers down inside rolldown with a message about a module
+ * specifier, and the publish that follows would label a build against a layer
+ * that was never there.
+ *
+ * The TYPE is inferred from this schema instead of imported. `BuildTarget` is
+ * declared in `@valbuild/tanstack-build`, which has no zod and deliberately
+ * almost no dependencies -- it goes into a browser bundle -- and this package
+ * is imported by everything. The declarations are kept honest at the one place
+ * the value is used: it is passed straight into `buildUserApp({ target })`, so
+ * a drift between them is a compile error at that call rather than a runtime
+ * surprise.
+ */
+var buildTargetResponse = zod.z.object({
+  base: zod.z.object({
+    rev: zod.z.string(),
+    shellRev: zod.z.string(),
+    rscShellRev: zod.z.string(),
+    modules: zod.z.record(zod.z.string(), zod.z.string()),
+    rscModules: zod.z.record(zod.z.string(), zod.z.string()),
+    paths: zod.z.object({
+      baseFromProject: zod.z.string(),
+      projectVendorDir: zod.z.string(),
+      rscVendorBase: zod.z.string(),
+      rscRuntimeSpecifier: zod.z.string(),
+      rscRuntimePath: zod.z.string(),
+      flightServer: zod.z.string(),
+      serverFnBase: zod.z.string()
+    }),
+    /*
+     * What the base layer is built from and what its chunks export, which
+     * `val publish` checks a project's layer against (`BuildTarget.base` in
+     * @valbuild/tanstack-build). Declared, because `z.object` DROPS a key it
+     * does not name: left out, they never reached the build, and every
+     * publish skipped both checks while saying the platform had not sent them.
+     * Optional, for a platform that predates them.
+     */
+    pins: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+    exports: zod.z.object({
+      worker: zod.z.record(zod.z.string(), zod.z.array(zod.z.string())),
+      browser: zod.z.record(zod.z.string(), zod.z.array(zod.z.string()))
+    }).optional()
+  }),
+  project: zod.z.object({
+    rev: zod.z.string().nullable(),
+    rsc: zod.z["boolean"](),
+    modules: zod.z.record(zod.z.string(), zod.z.string()),
+    css: zod.z.record(zod.z.string(), zod.z.string()),
+    workerOnly: zod.z.array(zod.z.string())
+  }),
+  /**
+   * The project's branch: what a build is wired at, so its Val saves where
+   * publishes commit. Optional, for a content service that predates it.
+   */
+  branch: zod.z.string().optional()
+});
+/**
+ * `null` files is a real answer: a project that has never published.
+ *
+ * Distinguished from an empty record, which would be a project that published
+ * nothing -- and which a build would take as "no entry point" rather than as
+ * "there is nothing here yet".
+ */
+var projectSourceResponse = zod.z.object({
+  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()
+});
+/**
+ * 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");
+};
+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(),
+  movedTo: zod.z.object({
+    proposal: zod.z.string(),
+    displayName: zod.z.string(),
+    changes: zod.z.number()
+  }).optional()
+}), 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()),
+  contentOnly: zod.z.literal(true).optional()
+});
+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.
+ *
+ * Every non-2xx is `{ statusCode, message, details? }`, and the publish routes
+ * put `PublishProblem[]` in `details` - a declaration is answered with EVERY
+ * problem rather than the first, because finding them one round trip at a time
+ * is how a publish takes six attempts. Anything else in there is somebody
+ * else's `details` and is left to the caller's own message.
+ */
+function parseProblems(details) {
+  var parsed = zod.z.array(publishProblem).safeParse(details);
+  return parsed.success ? parsed.data : [];
+}
+function parse(schema, body, call) {
+  var parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new PublishProtocolError("".concat(call, " answered with something this publisher cannot read: ").concat(zodValidationError.fromError(parsed.error).toString()));
+  }
+  return parsed.data;
+}
+
+exports.PublishProtocolError = PublishProtocolError;
+exports._objectWithoutProperties = _objectWithoutProperties;
+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;