@valbuild/shared 0.148.6 → 0.149.7

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

@@ -0,0 +1,2466 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var slicedToArray = require('../../dist/slicedToArray-af50e684.cjs.prod.js');
+var createForOfIteratorHelper = require('../../dist/createForOfIteratorHelper-90e6a8b6.cjs.prod.js');
+var protocol = require('../../dist/protocol-1c13de0d.cjs.prod.js');
+var zod = require('zod');
+var proposalProject = require('../../dist/proposalProject-28550146.cjs.prod.js');
+require('zod-validation-error');
+
+/*
+ * The one JSON call the Studio makes through its own origin's publish proxy,
+ * and the errors it throws. Apart from `publishClient.ts` (which re-exports
+ * all three) so that a worker can make the same call without importing the
+ * publish client's parsers, and `@valbuild/shared` with them.
+ */
+
+/**
+ * Who hears of a refusal's body before it is thrown: the Studio's shell, which
+ * says a refusal of the project's plan with the next step (`planRefusal.ts` in
+ * `@valbuild/ui`). One listener; setting it again replaces it.
+ */
+var refusalListener = null;
+function onPublishRefusal(listener) {
+  refusalListener = listener;
+}
+
+/** The publish API refused, and said why. */
+var StudioPublishError = /*#__PURE__*/function (_Error) {
+  function StudioPublishError(statusCode, message, body) {
+    var _this;
+    slicedToArray._classCallCheck(this, StudioPublishError);
+    _this = slicedToArray._callSuper(this, StudioPublishError, [message]);
+    createForOfIteratorHelper._defineProperty(_this, "statusCode", void 0);
+    createForOfIteratorHelper._defineProperty(_this, "body", void 0);
+    _this.name = "StudioPublishError";
+    _this.statusCode = statusCode;
+    _this.body = body;
+    return _this;
+  }
+  slicedToArray._inherits(StudioPublishError, _Error);
+  return slicedToArray._createClass(StudioPublishError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+
+/**
+ * Was this a failure that asking again could get past?
+ *
+ * No answer at all (the request never got through) and the answers that mean
+ * "not now" -- a timeout, too many requests, a server or gateway error. Every
+ * other status is content answering, and the same request gets the same
+ * answer.
+ */
+function isTransientPublishError(error) {
+  if (!(error instanceof StudioPublishError)) return true;
+  return error.statusCode >= 500 || error.statusCode === 408 || error.statusCode === 429;
+}
+
+/**
+ * One JSON call through this origin, with the session cookie: its body, or a
+ * `StudioPublishError` carrying the answer's own message.
+ */
+function callJson(_x, _x2, _x3, _x4) {
+  return _callJson.apply(this, arguments);
+}
+function _callJson() {
+  _callJson = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(fetchImpl, url, method, body) {
+    var res, text, parsed, _refusalListener, message;
+    return slicedToArray._regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          _context.n = 1;
+          return fetchImpl(url, createForOfIteratorHelper._objectSpread2({
+            method: method,
+            // The session cookie is the whole credential this end has.
+            credentials: "same-origin"
+          }, body === undefined ? {} : {
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+          }));
+        case 1:
+          res = _context.v;
+          _context.n = 2;
+          return res.text();
+        case 2:
+          text = _context.v;
+          try {
+            parsed = text === "" ? undefined : JSON.parse(text);
+          } catch (_unused) {
+            parsed = undefined;
+          }
+          if (res.ok) {
+            _context.n = 3;
+            break;
+          }
+          // A publish the plan does not allow (a trial's 3 publishes, a trial that
+          // ended): the shell says it, with the next step. See `planRefusal`.
+          (_refusalListener = refusalListener) === null || _refusalListener === void 0 || _refusalListener(parsed);
+          message = createForOfIteratorHelper._typeof(parsed) === "object" && parsed !== null && "message" in parsed && typeof parsed.message === "string" ? parsed.message : "The publish API answered ".concat(res.status, ".");
+          throw new StudioPublishError(res.status, message, parsed);
+        case 3:
+          return _context.a(2, parsed);
+      }
+    }, _callee);
+  }));
+  return _callJson.apply(this, arguments);
+}
+
+/** An artifact the live build has and this publish re-declares by hash. */
+
+/** See {@link StudioPublishClient.publicFiles}. */
+
+/** Object storage refused the bytes, or could not be reached. */
+var StudioUploadError = /*#__PURE__*/function (_Error) {
+  function StudioUploadError(statusCode, key, message) {
+    var _this;
+    slicedToArray._classCallCheck(this, StudioUploadError);
+    _this = slicedToArray._callSuper(this, StudioUploadError, [message]);
+    createForOfIteratorHelper._defineProperty(_this, "statusCode", void 0);
+    createForOfIteratorHelper._defineProperty(_this, "key", void 0);
+    _this.name = "StudioUploadError";
+    _this.statusCode = statusCode;
+    _this.key = key;
+    return _this;
+  }
+  slicedToArray._inherits(StudioUploadError, _Error);
+  return slicedToArray._createClass(StudioUploadError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+/**
+ * A slot's permission to write has run out.
+ *
+ * Its own shape because it is not a failure: the answer is to declare again for
+ * fresh slots, and a publish that treated it as one would give up an upload
+ * short of the finish.
+ */
+
+/*
+ * One request for both halves of the answer. A client lives for one deploy,
+ * so this is the source as that deploy read it -- two requests could read
+ * two different builds' files.
+ */
+
+function isExpiredSlot(error) {
+  return error instanceof StudioUploadError && error.statusCode === 403;
+}
+
+/**
+ * Where content's publish API is reached: through Val's proxy on this origin
+ * (`api`, the Studio), or directly (`publishApi`, `<content>/v1`: home's
+ * upgrade page, whose `fetchImpl` adds the project token).
+ */
+
+function publishApiOf(at) {
+  return "publishApi" in at ? at.publishApi.replace(/\/+$/, "") : "".concat(at.api.replace(/\/+$/, ""), "/publish-api");
+}
+function createStudioPublishClient(options) {
+  var _options$fetchImpl;
+  var fetchImpl = (_options$fetchImpl = options.fetchImpl) !== null && _options$fetchImpl !== void 0 ? _options$fetchImpl : fetch;
+  var proxy = publishApiOf(options);
+  var call = function call(path, method, body) {
+    return callJson(fetchImpl, "".concat(proxy).concat(path), method, body);
+  };
+  var source = null;
+  var readSource = function readSource() {
+    return source !== null && source !== void 0 ? source : source = call("/project-source", "GET").then(protocol.parseProjectSource);
+  };
+  return {
+    buildTarget: function () {
+      var _buildTarget = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee() {
+        var _t;
+        return slicedToArray._regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _t = protocol.parseBuildTarget;
+              _context.n = 1;
+              return call("/build-target", "GET");
+            case 1:
+              return _context.a(2, _t(_context.v));
+          }
+        }, _callee);
+      }));
+      function buildTarget() {
+        return _buildTarget.apply(this, arguments);
+      }
+      return buildTarget;
+    }(),
+    projectSource: function () {
+      var _projectSource = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2() {
+        return slicedToArray._regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              _context2.n = 1;
+              return readSource();
+            case 1:
+              return _context2.a(2, _context2.v.files);
+          }
+        }, _callee2);
+      }));
+      function projectSource() {
+        return _projectSource.apply(this, arguments);
+      }
+      return projectSource;
+    }(),
+    publicFiles: function () {
+      var _publicFiles = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee3() {
+        var _yield$readSource, publicFiles, publicPaths;
+        return slicedToArray._regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _context3.n = 1;
+              return readSource();
+            case 1:
+              _yield$readSource = _context3.v;
+              publicFiles = _yield$readSource.publicFiles;
+              publicPaths = _yield$readSource.publicPaths;
+              if (!publicFiles) {
+                _context3.n = 2;
+                break;
+              }
+              return _context3.a(2, {
+                carried: publicFiles
+              });
+            case 2:
+              if (!publicPaths) {
+                _context3.n = 3;
+                break;
+              }
+              return _context3.a(2, {
+                paths: publicPaths
+              });
+            case 3:
+              return _context3.a(2, null);
+          }
+        }, _callee3);
+      }));
+      function publicFiles() {
+        return _publicFiles.apply(this, arguments);
+      }
+      return publicFiles;
+    }(),
+    declare: function () {
+      var _declare = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee4(body) {
+        var _t2;
+        return slicedToArray._regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              _t2 = protocol.parseDeclare;
+              _context4.n = 1;
+              return call("/publish", "POST", body);
+            case 1:
+              return _context4.a(2, _t2(_context4.v));
+          }
+        }, _callee4);
+      }));
+      function declare(_x) {
+        return _declare.apply(this, arguments);
+      }
+      return declare;
+    }(),
+    confirmArtifacts: function () {
+      var _confirmArtifacts = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee5(publishId) {
+        var _t3;
+        return slicedToArray._regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              _t3 = protocol.parseArtifacts;
+              _context5.n = 1;
+              return call(publishStep(publishId, "artifacts"), "POST");
+            case 1:
+              return _context5.a(2, _t3(_context5.v));
+          }
+        }, _callee5);
+      }));
+      function confirmArtifacts(_x2) {
+        return _confirmArtifacts.apply(this, arguments);
+      }
+      return confirmArtifacts;
+    }(),
+    verify: function () {
+      var _verify = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee6(publishId) {
+        var _t4;
+        return slicedToArray._regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              _t4 = protocol.parseVerify;
+              _context6.n = 1;
+              return call(publishStep(publishId, "verify"), "POST");
+            case 1:
+              return _context6.a(2, _t4(_context6.v));
+          }
+        }, _callee6);
+      }));
+      function verify(_x3) {
+        return _verify.apply(this, arguments);
+      }
+      return verify;
+    }(),
+    promote: function () {
+      var _promote = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee7(publishId) {
+        var _t5;
+        return slicedToArray._regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              _t5 = protocol.parsePromote;
+              _context7.n = 1;
+              return call(publishStep(publishId, "promote"), "POST");
+            case 1:
+              return _context7.a(2, _t5(_context7.v));
+          }
+        }, _callee7);
+      }));
+      function promote(_x4) {
+        return _promote.apply(this, arguments);
+      }
+      return promote;
+    }(),
+    status: function () {
+      var _status = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee8(publishId) {
+        var _t6;
+        return slicedToArray._regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              _t6 = protocol.parseStatus;
+              _context8.n = 1;
+              return call(publishStep(publishId), "GET");
+            case 1:
+              return _context8.a(2, _t6(_context8.v));
+          }
+        }, _callee8);
+      }));
+      function status(_x5) {
+        return _status.apply(this, arguments);
+      }
+      return status;
+    }(),
+    upload: function () {
+      var _upload = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee9(slot, body) {
+        var res, _t7;
+        return slicedToArray._regenerator().w(function (_context9) {
+          while (1) switch (_context9.p = _context9.n) {
+            case 0:
+              _context9.p = 0;
+              _context9.n = 1;
+              return fetchImpl(slot.url, {
+                method: slot.method,
+                headers: slot.headers,
+                body: body,
+                /*
+                 * A presigned URL authorises itself. Sending this origin's cookies to
+                 * a storage host would leak a session to somewhere that has no use
+                 * for it and no reason to be trusted with it.
+                 */
+                credentials: "omit"
+              });
+            case 1:
+              res = _context9.v;
+              _context9.n = 3;
+              break;
+            case 2:
+              _context9.p = 2;
+              _t7 = _context9.v;
+              throw new StudioUploadError(0, slot.key, "Could not reach storage for '".concat(slot.key, "': ").concat(_t7 instanceof Error ? _t7.message : String(_t7)));
+            case 3:
+              if (res.ok) {
+                _context9.n = 4;
+                break;
+              }
+              throw new StudioUploadError(res.status, slot.key, "Storage refused '".concat(slot.key, "' with ").concat(res.status, "."));
+            case 4:
+              return _context9.a(2);
+          }
+        }, _callee9, null, [[0, 2]]);
+      }));
+      function upload(_x6, _x7) {
+        return _upload.apply(this, arguments);
+      }
+      return upload;
+    }()
+  };
+}
+var publishStep = function publishStep(publishId, step) {
+  return "/publish/".concat(encodeURIComponent(publishId)).concat(step ? "/".concat(step) : "");
+};
+
+/** Which step the publish is on, for the one line an editor is shown. */
+
+/**
+ * How many times to declare again.
+ *
+ * Declaring mints upload slots, and a slot expires. Three rounds covers an
+ * upload that ran past the hour and a storage write that content did not see;
+ * a fourth would be the same failure a third time.
+ */
+var DECLARE_ROUNDS = 3;
+function runStudioPublish(_x) {
+  return _runStudioPublish.apply(this, arguments);
+}
+
+/** The problems a refusal carries, or none when its body names none. */
+function _runStudioPublish() {
+  _runStudioPublish = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(args) {
+    var client, artifacts, onPhase, bodyOf, publishId, confirmed, round, declared, slots, expired, _iterator, _step, _step$value, index, slot, body, confirmation, verified, promoted, _t, _t2, _t3;
+    return slicedToArray._regenerator().w(function (_context) {
+      while (1) switch (_context.p = _context.n) {
+        case 0:
+          client = args.client, artifacts = args.artifacts, onPhase = args.onPhase;
+          bodyOf = new Map(artifacts.map(function (a) {
+            return [a.key, a.body];
+          }));
+          publishId = null;
+          _context.p = 1;
+          confirmed = false;
+          round = 1;
+        case 2:
+          if (!(round <= DECLARE_ROUNDS && !confirmed)) {
+            _context.n = 23;
+            break;
+          }
+          onPhase({
+            kind: "declaring"
+          });
+          _context.n = 3;
+          return client.declare(args.declare);
+        case 3:
+          declared = _context.v;
+          publishId = declared.publishId;
+          if (!(declared.state === "live")) {
+            _context.n = 5;
+            break;
+          }
+          if (!(args.until === "confirmed")) {
+            _context.n = 4;
+            break;
+          }
+          return _context.a(2, {
+            status: "uploaded",
+            publishId: declared.publishId
+          });
+        case 4:
+          return _context.a(2, {
+            status: "already-live",
+            publishId: declared.publishId,
+            url: declared.project.siteUrl
+          });
+        case 5:
+          slots = declared.uploads;
+          expired = false;
+          _iterator = createForOfIteratorHelper._createForOfIteratorHelper(slots.entries());
+          _context.p = 6;
+          _iterator.s();
+        case 7:
+          if ((_step = _iterator.n()).done) {
+            _context.n = 13;
+            break;
+          }
+          _step$value = slicedToArray._slicedToArray(_step.value, 2), index = _step$value[0], slot = _step$value[1];
+          onPhase({
+            kind: "uploading",
+            done: index,
+            total: slots.length
+          });
+          body = bodyOf.get(slot.key);
+          if (!(body === undefined)) {
+            _context.n = 8;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "Content asked for an artifact this build did not produce: '".concat(slot.key, "'."),
+            problems: []
+          });
+        case 8:
+          _context.p = 8;
+          _context.n = 9;
+          return client.upload(slot, body);
+        case 9:
+          _context.n = 12;
+          break;
+        case 10:
+          _context.p = 10;
+          _t = _context.v;
+          if (!isExpiredSlot(_t)) {
+            _context.n = 11;
+            break;
+          }
+          // Not a failure: the hour on the slots ran out while they were
+          // being used. Declaring again mints fresh ones.
+          expired = true;
+          return _context.a(3, 13);
+        case 11:
+          throw _t;
+        case 12:
+          _context.n = 7;
+          break;
+        case 13:
+          _context.n = 15;
+          break;
+        case 14:
+          _context.p = 14;
+          _t2 = _context.v;
+          _iterator.e(_t2);
+        case 15:
+          _context.p = 15;
+          _iterator.f();
+          return _context.f(15);
+        case 16:
+          if (!expired) {
+            _context.n = 17;
+            break;
+          }
+          return _context.a(3, 22);
+        case 17:
+          onPhase({
+            kind: "uploading",
+            done: slots.length,
+            total: slots.length
+          });
+          onPhase({
+            kind: "confirming"
+          });
+          _context.n = 18;
+          return client.confirmArtifacts(declared.publishId);
+        case 18:
+          confirmation = _context.v;
+          if (!(confirmation.state === "awaiting-artifacts")) {
+            _context.n = 20;
+            break;
+          }
+          if (!(round === DECLARE_ROUNDS)) {
+            _context.n = 19;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "Some artifacts did not arrive as declared.",
+            problems: confirmation.problems
+          });
+        case 19:
+          return _context.a(3, 22);
+        case 20:
+          if (!(confirmation.state !== "ready")) {
+            _context.n = 21;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "Content left this publish in \"".concat(confirmation.state, "\" after confirming the artifacts."),
+            problems: confirmation.problems
+          });
+        case 21:
+          confirmed = true;
+        case 22:
+          round++;
+          _context.n = 2;
+          break;
+        case 23:
+          if (!(!confirmed || publishId === null)) {
+            _context.n = 24;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "The artifacts were not confirmed after ".concat(DECLARE_ROUNDS, " attempts."),
+            problems: []
+          });
+        case 24:
+          if (!(args.until === "confirmed")) {
+            _context.n = 25;
+            break;
+          }
+          return _context.a(2, {
+            status: "uploaded",
+            publishId: publishId
+          });
+        case 25:
+          onPhase({
+            kind: "verifying"
+          });
+          _context.n = 26;
+          return client.verify(publishId);
+        case 26:
+          verified = _context.v;
+          if (verified.ok) {
+            _context.n = 27;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "The build was uploaded but did not render, so nothing was published.",
+            problems: verified.problems
+          });
+        case 27:
+          onPhase({
+            kind: "promoting"
+          });
+          _context.n = 28;
+          return client.promote(publishId);
+        case 28:
+          promoted = _context.v;
+          if (!(promoted.state !== "live")) {
+            _context.n = 29;
+            break;
+          }
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: "The site was not moved to this build: it is \"".concat(promoted.state, "\"."),
+            problems: []
+          });
+        case 29:
+          return _context.a(2, {
+            status: "live",
+            publishId: publishId,
+            url: promoted.url
+          });
+        case 30:
+          _context.p = 30;
+          _t3 = _context.v;
+          return _context.a(2, {
+            status: "failed",
+            publishId: publishId,
+            message: _t3 instanceof StudioPublishError || _t3 instanceof Error ? _t3.message : String(_t3),
+            /*
+             * Content refuses with `{ statusCode, message, details }`, and the
+             * publish routes put EVERY problem in `details`. Without them the editor
+             * reads "This publish cannot be declared" and nothing about why.
+             */
+            problems: _t3 instanceof StudioPublishError ? problemsOf(_t3.body) : []
+          });
+      }
+    }, _callee, null, [[8, 10], [6, 14, 15, 16], [1, 30]]);
+  }));
+  return _runStudioPublish.apply(this, arguments);
+}
+var problemsOf = function problemsOf(body) {
+  return createForOfIteratorHelper._typeof(body) === "object" && body !== null && "details" in body ? protocol.parseProblems(body.details) : [];
+};
+
+/**
+ * Has the site moved onto other dependencies since this page loaded?
+ *
+ * A managed project's Studio is served by the site's own live build, so the
+ * Studio on screen -- its builder, its Val -- is the version that build was
+ * made with. When the site is updated (Settings → Updates, in this tab or
+ * another), every Studio opened before that is the OLD version, and a publish
+ * from one would build the site with the old builder, or, if it read its build
+ * target before the update went live, put the old dependencies back.
+ *
+ * So the page remembers which dependency layer the live build had when it
+ * loaded, and a publish compares that with the live build's now. They differ
+ * only when somebody moved the site's dependencies in between; the answer is
+ * to reload, which loses nothing -- unpublished changes are the server's.
+ *
+ * Read from `/__api/head`, which the platform answers on every site without a
+ * credential and which names the layer (`projectVendorRev`). Anything that
+ * cannot answer -- not on the platform, the loader unreachable, an older
+ * loader -- reads as "cannot tell", and "cannot tell" never blocks a publish.
+ */
+
+/**
+ * The layer, or `undefined` for "cannot tell". `null` is never READ -- a head
+ * that names no layer is "cannot tell" too, see `readLiveLayer` -- but is what
+ * a build target says for a project with none, which is why it is comparable.
+ */
+
+function readLiveLayer() {
+  return _readLiveLayer.apply(this, arguments);
+}
+
+/**
+ * Stale only on a positive answer from both readings. A page that could not
+ * tell what it loaded on, or cannot tell now, publishes as before.
+ */
+function _readLiveLayer() {
+  _readLiveLayer = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee() {
+    var fetchImpl,
+      res,
+      body,
+      _args = arguments;
+    return slicedToArray._regenerator().w(function (_context) {
+      while (1) switch (_context.p = _context.n) {
+        case 0:
+          fetchImpl = _args.length > 0 && _args[0] !== undefined ? _args[0] : fetch;
+          _context.p = 1;
+          _context.n = 2;
+          return fetchImpl("/__api/head", {
+            credentials: "same-origin",
+            cache: "no-store"
+          });
+        case 2:
+          res = _context.v;
+          if (res.ok) {
+            _context.n = 3;
+            break;
+          }
+          return _context.a(2, undefined);
+        case 3:
+          _context.n = 4;
+          return res.json()["catch"](function () {
+            return undefined;
+          });
+        case 4:
+          body = _context.v;
+          if (!(createForOfIteratorHelper._typeof(body) !== "object" || body === null || !("hash" in body))) {
+            _context.n = 5;
+            break;
+          }
+          return _context.a(2, undefined);
+        case 5:
+          return _context.a(2, "projectVendorRev" in body && typeof body.projectVendorRev === "string" ? body.projectVendorRev : undefined);
+        case 6:
+          _context.p = 6;
+          _context.v;
+          return _context.a(2, undefined);
+      }
+    }, _callee, null, [[1, 6]]);
+  }));
+  return _readLiveLayer.apply(this, arguments);
+}
+function layerMoved(loaded, now) {
+  if (loaded === undefined || now === undefined) return false;
+  return loaded !== now;
+}
+var loaded = null;
+
+/**
+ * Take the reading this page is compared against. Once per page: the first
+ * call wins, because a later one would record the layer an update just moved
+ * to and make a stale page look current.
+ */
+function rememberLoadedLayer() {
+  var fetchImpl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : fetch;
+  loaded !== null && loaded !== void 0 ? loaded : loaded = readLiveLayer(fetchImpl);
+}
+
+/** What {@link rememberLoadedLayer} read, or `undefined` if it never ran. */
+function loadedLayer() {
+  return loaded !== null && loaded !== void 0 ? loaded : Promise.resolve(undefined);
+}
+
+/** Has the live build's layer moved since this page loaded? */
+function siteMovedSinceLoad() {
+  return _siteMovedSinceLoad.apply(this, arguments);
+}
+
+/** The code a deploy refuses with when this page is out of date. */
+function _siteMovedSinceLoad() {
+  _siteMovedSinceLoad = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2() {
+    var fetchImpl,
+      before,
+      _args2 = arguments,
+      _t2,
+      _t3;
+    return slicedToArray._regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          fetchImpl = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : fetch;
+          _context2.n = 1;
+          return loadedLayer();
+        case 1:
+          before = _context2.v;
+          if (!(before === undefined)) {
+            _context2.n = 2;
+            break;
+          }
+          return _context2.a(2, false);
+        case 2:
+          _t2 = layerMoved;
+          _t3 = before;
+          _context2.n = 3;
+          return readLiveLayer(fetchImpl);
+        case 3:
+          return _context2.a(2, _t2(_t3, _context2.v));
+      }
+    }, _callee2);
+  }));
+  return _siteMovedSinceLoad.apply(this, arguments);
+}
+var STUDIO_OUT_OF_DATE = "STUDIO_OUT_OF_DATE";
+var STUDIO_OUT_OF_DATE_MESSAGE = "Your site was updated after this Studio was opened. Reload to publish. " + "Your changes are kept.";
+
+/*
+ * Whether this page has been told it is out of date. Module state rather than
+ * React state, because it is found in two places that share no component -- a
+ * publish's pre-check and the deploy under it -- and shown in a third.
+ */
+/**
+ * How many times a publish has been refused for it. A count rather than a
+ * flag, so a dialog dismissed once is shown again by the next refused press.
+ */
+var refusals = 0;
+var listeners = new Set();
+function markStudioOutOfDate() {
+  refusals++;
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(listeners),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var listener = _step.value;
+      listener();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function studioOutOfDateRefusals() {
+  return refusals;
+}
+function subscribeStudioOutOfDate(listener) {
+  listeners.add(listener);
+  return function () {
+    return listeners["delete"](listener);
+  };
+}
+
+/** For tests: forget everything this module has learnt. */
+function resetLoadedLayerForTests() {
+  loaded = null;
+  refusals = 0;
+  listeners.clear();
+}
+
+/**
+ * Where a project's route files live, if it has any.
+ *
+ * Spelled here rather than imported as `ROUTES_DIR` so this module keeps its
+ * one runtime reach into the builder package behind `loadBuilder` — the
+ * constant is four characters and the guard that says so is worth more. See
+ * `onlyBuilderRoot.test.ts`.
+ */
+var ROUTES_PREFIX = "src/routes/";
+
+/**
+ * Where a project's served-as-is files live, and the artifact prefix they are
+ * published under -- the same four letters either way, which is the contract
+ * (`public/favicon.ico` is requested as `/favicon.ico`). Spelled here for the
+ * reason `ROUTES_PREFIX` is.
+ */
+var PUBLIC_PREFIX = "public/";
+
+/**
+ * The binary files a commit wrote, as `/save` answered them.
+ *
+ * `unread` is files the server could not read back before committing. The
+ * build refuses over them: the site would link a file it does not serve.
+ */
+
+function runStudioDeploy(_x) {
+  return _runStudioDeploy.apply(this, arguments);
+}
+
+/**
+ * The stored source with a commit's files laid over it.
+ *
+ * A new record rather than an edit of the one read, which the caller may still
+ * hold. Val names module files with a leading `/`; the stored record does
+ * not, so the slash is dropped -- two spellings of one path would build the
+ * old file and publish the new one beside it.
+ */
+function _runStudioDeploy() {
+  _runStudioDeploy = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2(options) {
+    var _options$committedFil3, _git$commit, _git, _git$branch, _git2;
+    var client, onPhase, failed, publishByName, builder, target, source, carried, refetched, _options$target, _options$committedBin, _options$committedBin2, _options$committedFil, _yield$Promise$all, _yield$Promise$all2, readTarget, readSource, readPublic, unread, _options$committedFil2, build, git, wiredSource, _ref8, _options$branch, _yield$builder$bakedG, _options$committedBin3, _options$committedBin4, branch, wired, fileBased, generateRouteTree, binaries, extraInputs, input, name, held, live, artifacts, _live, declared, published, _t, _t2, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t0, _t1, _t10, _t11, _t12, _t13, _t14, _t15, _t16, _t17, _t18, _t19, _t20, _t21;
+    return slicedToArray._regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
+        case 0:
+          client = options.client, onPhase = options.onPhase;
+          failed = function failed(message) {
+            return {
+              status: "failed",
+              message: message,
+              problems: []
+            };
+          };
+          /*
+           * The build content already holds under this name, published as any build
+           * is -- or `null` when content holds none, or cannot be asked by name (one
+           * from before the question existed refuses an empty declaration), and the
+           * build has to be made.
+           *
+           * `null` only for a refusal of the DECLARE: once content has taken the
+           * build, what happens to it is that publish's outcome, a failure included.
+           * Building it again would not change it.
+           */
+          publishByName = /*#__PURE__*/function () {
+            var _ref7 = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(name, at) {
+              var _at$git$commit, _at$git, _at$git$branch, _at$git2;
+              var published;
+              return slicedToArray._regenerator().w(function (_context) {
+                while (1) switch (_context.n) {
+                  case 0:
+                    _context.n = 1;
+                    return runStudioPublish(createForOfIteratorHelper._objectSpread2({
+                      client: client,
+                      artifacts: [],
+                      declare: {
+                        buildHash: name,
+                        commit: (_at$git$commit = (_at$git = at.git) === null || _at$git === void 0 ? void 0 : _at$git.commit) !== null && _at$git$commit !== void 0 ? _at$git$commit : null,
+                        branch: (_at$git$branch = (_at$git2 = at.git) === null || _at$git2 === void 0 ? void 0 : _at$git2.branch) !== null && _at$git$branch !== void 0 ? _at$git$branch : null,
+                        layerRev: at.layerRev,
+                        // The build's, which content has: this tab built nothing to ask.
+                        linksOwnCss: null,
+                        artifacts: [],
+                        byReference: true
+                      },
+                      onPhase: onPhase
+                    }, options.until !== undefined ? {
+                      until: options.until
+                    } : {}));
+                  case 1:
+                    published = _context.v;
+                    if (!(published.status === "failed" && published.publishId === null)) {
+                      _context.n = 2;
+                      break;
+                    }
+                    return _context.a(2, null);
+                  case 2:
+                    return _context.a(2, asDeployResult(published));
+                }
+              }, _callee);
+            }));
+            return function publishByName(_x5, _x6) {
+              return _ref7.apply(this, arguments);
+            };
+          }();
+          _context2.p = 1;
+          onPhase({
+            kind: "getting-ready"
+          });
+          _context2.n = 2;
+          return options.loadBuilder();
+        case 2:
+          builder = _context2.v;
+          _context2.n = 4;
+          break;
+        case 3:
+          _context2.p = 3;
+          _t = _context2.v;
+          return _context2.a(2, failed(messageOf$2(_t)));
+        case 4:
+          _context2.p = 4;
+          onPhase({
+            kind: "reading"
+          });
+          /*
+           * Together, because they are one answer with two halves and neither is
+           * useful alone -- and because the round trip is the cost, not the work.
+           */
+          _context2.n = 5;
+          return Promise.all([(_options$target = options.target) !== null && _options$target !== void 0 ? _options$target : client.buildTarget(), client.projectSource(), client.publicFiles()]);
+        case 5:
+          _yield$Promise$all = _context2.v;
+          _yield$Promise$all2 = slicedToArray._slicedToArray(_yield$Promise$all, 3);
+          readTarget = _yield$Promise$all2[0];
+          readSource = _yield$Promise$all2[1];
+          readPublic = _yield$Promise$all2[2];
+          if (!(readSource === null)) {
+            _context2.n = 6;
+            break;
+          }
+          return _context2.a(2, failed("This project has no published source to build from. Publish it once " + "from a checkout before editing it here."));
+        case 6:
+          if (!(readTarget.project.rev === null)) {
+            _context2.n = 7;
+            break;
+          }
+          return _context2.a(2, failed("This project has no dependency layer yet, and one cannot be built " + "from the browser. Publish it once from a checkout, which builds it."));
+        case 7:
+          if (!(options.target === undefined && layerMoved(options.loadedLayer, readTarget.project.rev))) {
+            _context2.n = 8;
+            break;
+          }
+          return _context2.a(2, {
+            status: "failed",
+            message: STUDIO_OUT_OF_DATE_MESSAGE,
+            problems: [{
+              code: STUDIO_OUT_OF_DATE,
+              message: STUDIO_OUT_OF_DATE_MESSAGE
+            }]
+          });
+        case 8:
+          if (!(readPublic === null || "paths" in readPublic && options.fetchPublicFile === undefined)) {
+            _context2.n = 9;
+            break;
+          }
+          return _context2.a(2, failed("The Studio cannot tell which images and other public files this " + "site serves, so publishing would remove them. Publish it once from " + "a checkout with `val publish`, and the Studio can publish it from " + "then on."));
+        case 9:
+          unread = (_options$committedBin = (_options$committedBin2 = options.committedBinaryFiles) === null || _options$committedBin2 === void 0 ? void 0 : _options$committedBin2.unread) !== null && _options$committedBin !== void 0 ? _options$committedBin : [];
+          if (!(unread.length > 0)) {
+            _context2.n = 10;
+            break;
+          }
+          return _context2.a(2, failed("Your changes are saved, but ".concat(unread.join(", "), " could not be read ") + "back to build with, and the site would link a file it does not " + "serve. Try publishing again."));
+        case 10:
+          target = readTarget;
+          source = withCommittedFiles(readSource, (_options$committedFil = options.committedFiles) !== null && _options$committedFil !== void 0 ? _options$committedFil : null);
+          if (!("carried" in readPublic)) {
+            _context2.n = 11;
+            break;
+          }
+          carried = readPublic.carried;
+          refetched = {};
+          _context2.n = 13;
+          break;
+        case 11:
+          /*
+           * Content has no record of the live build -- a project cloned from a
+           * template seed -- but the loader knows what it serves, and this page is
+           * ON the site. So the files come from the site and go into the build;
+           * content holds their hashes after this publish and the next one
+           * carries them without fetching.
+           */
+          carried = [];
+          _context2.n = 12;
+          return refetchPublicFiles(readPublic.paths, (_options$committedFil2 = options.committedFiles) !== null && _options$committedFil2 !== void 0 ? _options$committedFil2 : null, options.fetchPublicFile);
+        case 12:
+          refetched = _context2.v;
+        case 13:
+          _context2.n = 15;
+          break;
+        case 14:
+          _context2.p = 14;
+          _t2 = _context2.v;
+          return _context2.a(2, failed(messageOf$2(_t2)));
+        case 15:
+          _context2.p = 15;
+          onPhase({
+            kind: "building"
+          });
+          /*
+           * The branch the last build was wired at, which is the only place one can
+           * be read from here -- `/stat` does not carry one and neither does
+           * `/save`. `null` when the record names none, which is a project that has
+           * only ever published commitlessly; content then answers from the
+           * project's own chain, where the answer always came from for a project
+           * whose content service is its store of record.
+           *
+           * The pair goes in BEFORE the build, and into the record published back as
+           * source, so the next publish reads it back and the two never disagree
+           * about which commit this build is wired at.
+           */
+          if (!((_options$branch = options.branch) !== null && _options$branch !== void 0)) {
+            _context2.n = 16;
+            break;
+          }
+          _t4 = _options$branch;
+          _context2.n = 21;
+          break;
+        case 16:
+          _context2.n = 17;
+          return builder.bakedGit(source);
+        case 17:
+          _t6 = _yield$builder$bakedG = _context2.v;
+          _t5 = _t6 === null;
+          if (_t5) {
+            _context2.n = 18;
+            break;
+          }
+          _t5 = _yield$builder$bakedG === void 0;
+        case 18:
+          if (!_t5) {
+            _context2.n = 19;
+            break;
+          }
+          _t7 = void 0;
+          _context2.n = 20;
+          break;
+        case 19:
+          _t7 = _yield$builder$bakedG.branch;
+        case 20:
+          _t4 = _t7;
+        case 21:
+          _t8 = _ref8 = _t4;
+          _t3 = _t8 !== null;
+          if (!_t3) {
+            _context2.n = 22;
+            break;
+          }
+          _t3 = _ref8 !== void 0;
+        case 22:
+          if (!_t3) {
+            _context2.n = 23;
+            break;
+          }
+          _t9 = _ref8;
+          _context2.n = 24;
+          break;
+        case 23:
+          _t9 = null;
+        case 24:
+          branch = _t9;
+          git = options.commit === null || branch === null ? null : {
+            commit: options.commit,
+            branch: branch
+          };
+          _context2.n = 25;
+          return builder.rebakeGit(source, git, options.job);
+        case 25:
+          wired = _context2.v;
+          wiredSource = wired;
+          fileBased = Object.keys(wired).some(function (path) {
+            return path.startsWith(ROUTES_PREFIX);
+          });
+          /*
+           * Read out before the branch, so the guard below and the call are the same
+           * narrowing rather than two that agree by inspection.
+           */
+          generateRouteTree = options.generateRouteTree;
+          if (!(fileBased && generateRouteTree === undefined)) {
+            _context2.n = 26;
+            break;
+          }
+          return _context2.a(2, failed("This project's pages are files under src/routes, and building those " + "needs a route generator this page was not given. Publish it from a " + "checkout, or mount the Studio in a deployment that supplies one."));
+        case 26:
+          binaries = splitBinaryFiles((_options$committedBin3 = (_options$committedBin4 = options.committedBinaryFiles) === null || _options$committedBin4 === void 0 ? void 0 : _options$committedBin4.files) !== null && _options$committedBin3 !== void 0 ? _options$committedBin3 : {});
+          /*
+           * What this build ships that it is not built from, so the build's name
+           * (`buildInputId`) changes with it: the live build's public files carried
+           * over by sha, and -- below -- the live stylesheet in place of an empty one.
+           */
+          extraInputs = Object.fromEntries(carried.map(function (_ref9) {
+            var key = _ref9.key,
+              sha256 = _ref9.sha256;
+            return ["carried:".concat(key), sha256];
+          }));
+          if (!(fileBased && generateRouteTree !== undefined)) {
+            _context2.n = 28;
+            break;
+          }
+          _context2.n = 27;
+          return generateRouteTree(wired);
+        case 27:
+          _t0 = _context2.v;
+          _context2.n = 29;
+          break;
+        case 28:
+          _t0 = wired;
+        case 29:
+          _t1 = _t0;
+          _t10 = createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, refetched), binaries.publicFiles);
+          _t11 = binaries.assets;
+          _t12 = wired;
+          _t13 = target;
+          _t14 = extraInputs;
+          input = {
+            files: _t1,
+            publicFiles: _t10,
+            assets: _t11,
+            projectSource: _t12,
+            target: _t13,
+            extraInputs: _t14
+          };
+          _context2.n = 30;
+          return builder.buildInputId(input)["catch"](function () {
+            return null;
+          });
+        case 30:
+          name = _context2.v;
+          if (!(name !== null)) {
+            _context2.n = 33;
+            break;
+          }
+          _context2.n = 31;
+          return publishByName(name, {
+            git: git,
+            layerRev: target.project.rev
+          });
+        case 31:
+          held = _context2.v;
+          if (!(held !== null)) {
+            _context2.n = 32;
+            break;
+          }
+          return _context2.a(2, held);
+        case 32:
+          onPhase({
+            kind: "building"
+          });
+        case 33:
+          _context2.n = 34;
+          return builder.buildUserApp(input);
+        case 34:
+          build = _context2.v;
+          if (!(build.cssCode === "" && options.liveStylesheet)) {
+            _context2.n = 37;
+            break;
+          }
+          _context2.n = 35;
+          return options.liveStylesheet();
+        case 35:
+          live = _context2.v;
+          if (!(live !== "")) {
+            _context2.n = 37;
+            break;
+          }
+          _t15 = createForOfIteratorHelper._objectSpread2;
+          _t16 = createForOfIteratorHelper._objectSpread2({}, build);
+          _t17 = {};
+          _t18 = live;
+          _context2.n = 36;
+          return builder.buildInputId(createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, input), {}, {
+            extraInputs: createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, extraInputs), {}, {
+              liveStylesheet: live
+            })
+          }));
+        case 36:
+          _t19 = _context2.v;
+          build = _t15(_t16, _t17, {
+            cssCode: _t18,
+            hash: _t19
+          });
+        case 37:
+          _context2.n = 39;
+          break;
+        case 38:
+          _context2.p = 38;
+          _t20 = _context2.v;
+          return _context2.a(2, failed(messageOf$2(_t20)));
+        case 39:
+          _context2.p = 39;
+          _context2.n = 40;
+          return builder.publishArtifacts(build, {
+            projectSource: wiredSource
+          });
+        case 40:
+          artifacts = _context2.v;
+          _context2.n = 42;
+          break;
+        case 41:
+          _context2.p = 41;
+          _t21 = _context2.v;
+          return _context2.a(2, failed(messageOf$2(_t21)));
+        case 42:
+          if (!(options.target === undefined && options.liveLayer !== undefined)) {
+            _context2.n = 44;
+            break;
+          }
+          _context2.n = 43;
+          return options.liveLayer()["catch"](function () {
+            return undefined;
+          });
+        case 43:
+          _live = _context2.v;
+          if (!layerMoved(options.loadedLayer, _live)) {
+            _context2.n = 44;
+            break;
+          }
+          return _context2.a(2, {
+            status: "failed",
+            message: STUDIO_OUT_OF_DATE_MESSAGE,
+            problems: [{
+              code: STUDIO_OUT_OF_DATE,
+              message: STUDIO_OUT_OF_DATE_MESSAGE
+            }]
+          });
+        case 44:
+          declared = [].concat(slicedToArray._toConsumableArray(artifacts.map(function (_ref0) {
+            var key = _ref0.key,
+              sha256 = _ref0.sha256,
+              bytes = _ref0.bytes;
+            return {
+              key: key,
+              sha256: sha256,
+              bytes: bytes
+            };
+          })), slicedToArray._toConsumableArray(carriedInto(artifacts, carried, (_options$committedFil3 = options.committedFiles) !== null && _options$committedFil3 !== void 0 ? _options$committedFil3 : null)));
+          _context2.n = 45;
+          return runStudioPublish(createForOfIteratorHelper._objectSpread2({
+            client: client,
+            artifacts: artifacts,
+            declare: {
+              buildHash: build.hash,
+              /*
+               * What went into the build, not what the caller asked for. A declare
+               * naming a commit the bundle was not wired at labels a build as
+               * something it is not.
+               */
+              commit: (_git$commit = (_git = git) === null || _git === void 0 ? void 0 : _git.commit) !== null && _git$commit !== void 0 ? _git$commit : null,
+              branch: (_git$branch = (_git2 = git) === null || _git2 === void 0 ? void 0 : _git2.branch) !== null && _git$branch !== void 0 ? _git$branch : null,
+              layerRev: target.project.rev,
+              // The base layer this build was compiled against, so the platform can
+              // refuse it if it has been deployed since.
+              baseRev: build.vendorRev,
+              linksOwnCss: build.linksOwnCss,
+              artifacts: declared
+            },
+            onPhase: onPhase
+          }, options.until !== undefined ? {
+            until: options.until
+          } : {}));
+        case 45:
+          published = _context2.v;
+          return _context2.a(2, asDeployResult(published));
+      }
+    }, _callee2, null, [[39, 41], [15, 38], [4, 14], [1, 3]]);
+  }));
+  return _runStudioDeploy.apply(this, arguments);
+}
+function withCommittedFiles(source, committed) {
+  if (committed === null) return source;
+  var out = createForOfIteratorHelper._objectSpread2({}, source);
+  for (var _i = 0, _Object$entries = Object.entries(committed); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2),
+      path = _Object$entries$_i[0],
+      content = _Object$entries$_i[1];
+    var key = path.replace(/^\/+/, "");
+    if (content === null) delete out[key];else out[key] = content;
+  }
+  return out;
+}
+
+/**
+ * A commit's binary files, as the build takes them: `public/...` served as is,
+ * everything else an asset an import can reach. Keys lose the leading `/`
+ * Val's paths carry, as in {@link withCommittedFiles}.
+ */
+function splitBinaryFiles(files) {
+  var publicFiles = {};
+  var assets = {};
+  for (var _i2 = 0, _Object$entries2 = Object.entries(files); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i2], 2),
+      path = _Object$entries2$_i[0],
+      base64 = _Object$entries2$_i[1];
+    var key = path.replace(/^\/+/, "");
+    if (key.startsWith(PUBLIC_PREFIX)) publicFiles[key] = base64;else assets[key] = base64;
+  }
+  return {
+    publicFiles: publicFiles,
+    assets: assets
+  };
+}
+
+/**
+ * The live site's public files, fetched to be built with, as `public/<path>`.
+ *
+ * All of them but the ones the commit deleted -- a replaced one is overridden
+ * by the commit's own bytes where the two are merged. A file that cannot be
+ * fetched fails the publish by name: leaving it out is the hole this exists
+ * to prevent.
+ */
+function refetchPublicFiles(_x2, _x3, _x4) {
+  return _refetchPublicFiles.apply(this, arguments);
+}
+/**
+ * The live build's public files this build keeps, re-declared by hash.
+ *
+ * All of them, except the ones this build produced itself (a file the commit
+ * replaced) and the ones the commit deleted. Content holds the bytes already,
+ * so this uploads nothing -- and if it has lost one, it asks for it, and
+ * `runStudioPublish` refuses rather than publishing a hole.
+ */
+function _refetchPublicFiles() {
+  _refetchPublicFiles = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee3(paths, committed, fetchPublicFile) {
+    var deleted, out, _iterator, _step, path, key, _t22, _t23;
+    return slicedToArray._regenerator().w(function (_context3) {
+      while (1) switch (_context3.p = _context3.n) {
+        case 0:
+          deleted = new Set(Object.entries(committed !== null && committed !== void 0 ? committed : {}).filter(function (_ref1) {
+            var _ref10 = slicedToArray._slicedToArray(_ref1, 2),
+              content = _ref10[1];
+            return content === null;
+          }).map(function (_ref11) {
+            var _ref12 = slicedToArray._slicedToArray(_ref11, 1),
+              path = _ref12[0];
+            return path.replace(/^\/+/, "");
+          }));
+          out = {};
+          _iterator = createForOfIteratorHelper._createForOfIteratorHelper(paths);
+          _context3.p = 1;
+          _iterator.s();
+        case 2:
+          if ((_step = _iterator.n()).done) {
+            _context3.n = 8;
+            break;
+          }
+          path = _step.value;
+          key = PUBLIC_PREFIX + path.replace(/^\/+/, "");
+          if (!deleted.has(key)) {
+            _context3.n = 3;
+            break;
+          }
+          return _context3.a(3, 7);
+        case 3:
+          if (!(fetchPublicFile === undefined)) {
+            _context3.n = 4;
+            break;
+          }
+          throw new Error("No way to read /".concat(path, " from the site to build with."));
+        case 4:
+          _context3.p = 4;
+          _context3.n = 5;
+          return fetchPublicFile(path.replace(/^\/+/, ""));
+        case 5:
+          out[key] = _context3.v;
+          _context3.n = 7;
+          break;
+        case 6:
+          _context3.p = 6;
+          _t22 = _context3.v;
+          throw new Error("The site's /".concat(path, " could not be read to build with, and leaving it ") + "out would remove it: ".concat(messageOf$2(_t22)), {
+            cause: _t22
+          });
+        case 7:
+          _context3.n = 2;
+          break;
+        case 8:
+          _context3.n = 10;
+          break;
+        case 9:
+          _context3.p = 9;
+          _t23 = _context3.v;
+          _iterator.e(_t23);
+        case 10:
+          _context3.p = 10;
+          _iterator.f();
+          return _context3.f(10);
+        case 11:
+          return _context3.a(2, out);
+      }
+    }, _callee3, null, [[4, 6], [1, 9, 10, 11]]);
+  }));
+  return _refetchPublicFiles.apply(this, arguments);
+}
+function carriedInto(built, carried, committed) {
+  var produced = new Set(built.map(function (_ref) {
+    var key = _ref.key;
+    return key;
+  }));
+  var deleted = new Set(Object.entries(committed !== null && committed !== void 0 ? committed : {}).filter(function (_ref2) {
+    var _ref3 = slicedToArray._slicedToArray(_ref2, 2),
+      content = _ref3[1];
+    return content === null;
+  }).map(function (_ref4) {
+    var _ref5 = slicedToArray._slicedToArray(_ref4, 1),
+      path = _ref5[0];
+    return path.replace(/^\/+/, "");
+  }));
+  return carried.filter(function (_ref6) {
+    var key = _ref6.key;
+    return key.startsWith(PUBLIC_PREFIX) && !produced.has(key) && !deleted.has(key);
+  });
+}
+var asDeployResult = function asDeployResult(published) {
+  switch (published.status) {
+    case "live":
+      return {
+        status: "live",
+        url: published.url
+      };
+    case "already-live":
+      return {
+        status: "already-live",
+        url: published.url
+      };
+    case "uploaded":
+      return {
+        status: "uploaded",
+        publishId: published.publishId
+      };
+    case "failed":
+      return {
+        status: "failed",
+        message: published.message,
+        problems: published.problems
+      };
+  }
+};
+
+/**
+ * A thrown thing, as a sentence.
+ *
+ * `String(error)` on an Error gives `Error: ...`, which reads as a stack trace
+ * leaking into the page. The message alone is what was written for a person.
+ */
+var messageOf$2 = function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+};
+
+var _excluded = ["buildable"];
+
+/**
+ * Publishing as a queued job, as a Studio tab speaks it.
+ *
+ * valbuild/home's docs/app-mode.md, "Publishing is a queued job", is the
+ * design: a press is a REQUEST that returns at once; the tab that pressed runs
+ * the job it is given -- prepare, build, upload -- and content runs verify and
+ * the seal. Everything goes through this deployment: the job routes through
+ * the publish proxy, and the prepare through this server's own route, which is
+ * the one place a job's sources can be computed.
+ */
+
+/** What the tab builds a job from: `/api/val/publish-job-prepare`'s answer. */
+
+function createStudioJobClient(options) {
+  var _options$fetchImpl;
+  var fetchImpl = (_options$fetchImpl = options.fetchImpl) !== null && _options$fetchImpl !== void 0 ? _options$fetchImpl : fetch;
+  var publishApi = publishApiOf(options);
+  var proposalsApi = "proposalsApi" in options ? options.proposalsApi.replace(/\/+$/, "") : "".concat(options.api.replace(/\/+$/, ""), "/proposals-api");
+  var proxy = function proxy(path, method, body) {
+    return callJson(fetchImpl, "".concat(publishApi).concat(path), method, body);
+  };
+  var job = function job(jobId, step) {
+    return "/publish-jobs/".concat(encodeURIComponent(jobId), "/").concat(step);
+  };
+  return {
+    press: function () {
+      var _press = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(requestId, tab) {
+        var _t;
+        return slicedToArray._regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _t = protocol.parsePress;
+              _context.n = 1;
+              return proxy("/publish-requests", "POST", {
+                requestId: requestId,
+                tab: tab
+              });
+            case 1:
+              return _context.a(2, _t(_context.v, "POST /v1/publish-requests"));
+          }
+        }, _callee);
+      }));
+      function press(_x, _x2) {
+        return _press.apply(this, arguments);
+      }
+      return press;
+    }(),
+    pressMerge: function () {
+      var _pressMerge = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2(proposal, requestId, tab, anyway) {
+        var _t2;
+        return slicedToArray._regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              _t2 = protocol.parsePress;
+              _context2.n = 1;
+              return callJson(fetchImpl, "".concat(proposalsApi, "/").concat(encodeURIComponent(proposal), "/merge"), "POST", createForOfIteratorHelper._objectSpread2({
+                requestId: requestId,
+                tab: tab
+              }, anyway !== undefined && anyway.length > 0 ? {
+                anyway: anyway
+              } : {}));
+            case 1:
+              return _context2.a(2, _t2(_context2.v, "POST /v1/proposals/{name}/merge"));
+          }
+        }, _callee2);
+      }));
+      function pressMerge(_x3, _x4, _x5, _x6) {
+        return _pressMerge.apply(this, arguments);
+      }
+      return pressMerge;
+    }(),
+    tryAgain: function () {
+      var _tryAgain = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee3(requestId, tab) {
+        var _t3;
+        return slicedToArray._regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _t3 = protocol.parsePress;
+              _context3.n = 1;
+              return proxy("/publish-requests/try-again", "POST", {
+                requestId: requestId,
+                tab: tab
+              });
+            case 1:
+              return _context3.a(2, _t3(_context3.v, "POST /v1/publish-requests/try-again"));
+          }
+        }, _callee3);
+      }));
+      function tryAgain(_x7, _x8) {
+        return _tryAgain.apply(this, arguments);
+      }
+      return tryAgain;
+    }(),
+    requestStatus: function () {
+      var _requestStatus = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee4(requestId) {
+        var _t4;
+        return slicedToArray._regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              _t4 = protocol.parseRequestStatus;
+              _context4.n = 1;
+              return proxy("/publish-requests/".concat(encodeURIComponent(requestId)), "GET");
+            case 1:
+              return _context4.a(2, _t4(_context4.v).request);
+          }
+        }, _callee4);
+      }));
+      function requestStatus(_x9) {
+        return _requestStatus.apply(this, arguments);
+      }
+      return requestStatus;
+    }(),
+    next: function () {
+      var _next = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee5(tab) {
+        var _t5;
+        return slicedToArray._regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              _t5 = protocol.parseJob;
+              _context5.n = 1;
+              return proxy("/publish-jobs/next", "POST", {
+                tab: tab
+              });
+            case 1:
+              return _context5.a(2, _t5(_context5.v, "POST /v1/publish-jobs/next").job);
+          }
+        }, _callee5);
+      }));
+      function next(_x0) {
+        return _next.apply(this, arguments);
+      }
+      return next;
+    }(),
+    prepare: function () {
+      var _prepare = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee6(tabJob, tab) {
+        var merged, answer, _t6;
+        return slicedToArray._regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              if (!tabJob.patches.some(isMergeChange)) {
+                _context6.n = 2;
+                break;
+              }
+              _t6 = MergePrepareAnswer;
+              _context6.n = 1;
+              return proxy(job(tabJob.id, "merge-prepare"), "POST", {
+                tab: tab
+              });
+            case 1:
+              merged = _t6.parse.call(_t6, _context6.v);
+              return _context6.a(2, createForOfIteratorHelper._objectSpread2({
+                job: merged.job,
+                sourceFiles: merged.sourceFiles,
+                binaryFiles: {},
+                binaryFilesUnread: [],
+                branch: null,
+                buildable: true
+              }, merged.target !== undefined ? {
+                target: protocol.parseBuildTarget(merged.target)
+              } : {}));
+            case 2:
+              if ("api" in options) {
+                _context6.n = 3;
+                break;
+              }
+              throw new Error("Only a merge's job can be run here: a site change's job needs the Studio.");
+            case 3:
+              _context6.n = 4;
+              return callJson(fetchImpl, "".concat(options.api.replace(/\/+$/, ""), "/publish-job-prepare"), "POST", {
+                jobId: tabJob.id,
+                tab: tab,
+                patchIds: tabJob.patches
+              });
+            case 4:
+              answer = _context6.v;
+              return _context6.a(2, parsePreparedJob(answer));
+          }
+        }, _callee6);
+      }));
+      function prepare(_x1, _x10) {
+        return _prepare.apply(this, arguments);
+      }
+      return prepare;
+    }(),
+    step: function () {
+      var _step = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee7(jobId, body) {
+        var _t7;
+        return slicedToArray._regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              _t7 = protocol.parseJob;
+              _context7.n = 1;
+              return proxy(job(jobId, "steps"), "POST", body);
+            case 1:
+              return _context7.a(2, _t7(_context7.v, "POST /v1/publish-jobs/{id}/steps").job);
+          }
+        }, _callee7);
+      }));
+      function step(_x11, _x12) {
+        return _step.apply(this, arguments);
+      }
+      return step;
+    }(),
+    renew: function () {
+      var _renew = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee8(jobId, tab) {
+        var _t8;
+        return slicedToArray._regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              _t8 = protocol.parseRenew;
+              _context8.n = 1;
+              return proxy(job(jobId, "renew"), "POST", {
+                tab: tab
+              });
+            case 1:
+              return _context8.a(2, _t8(_context8.v).renewed);
+          }
+        }, _callee8);
+      }));
+      function renew(_x13, _x14) {
+        return _renew.apply(this, arguments);
+      }
+      return renew;
+    }(),
+    cancel: function () {
+      var _cancel = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee9(jobId) {
+        var _t9;
+        return slicedToArray._regenerator().w(function (_context9) {
+          while (1) switch (_context9.n) {
+            case 0:
+              _t9 = protocol.parseCancel;
+              _context9.n = 1;
+              return proxy(job(jobId, "cancel"), "POST", {});
+            case 1:
+              return _context9.a(2, _t9(_context9.v).cancelled);
+          }
+        }, _callee9);
+      }));
+      function cancel(_x15) {
+        return _cancel.apply(this, arguments);
+      }
+      return cancel;
+    }(),
+    discard: function () {
+      var _discard = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee0(jobId) {
+        var _t0;
+        return slicedToArray._regenerator().w(function (_context0) {
+          while (1) switch (_context0.n) {
+            case 0:
+              _t0 = protocol.parseDiscard;
+              _context0.n = 1;
+              return proxy(job(jobId, "discard"), "POST", {});
+            case 1:
+              return _context0.a(2, _t0(_context0.v).stillHeld);
+          }
+        }, _callee0);
+      }));
+      function discard(_x16) {
+        return _discard.apply(this, arguments);
+      }
+      return discard;
+    }(),
+    newestCiRun: function () {
+      var _newestCiRun = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee1() {
+        var _t1;
+        return slicedToArray._regenerator().w(function (_context1) {
+          while (1) switch (_context1.n) {
+            case 0:
+              _t1 = protocol.parseNewestCiRun;
+              _context1.n = 1;
+              return proxy("/ci-runs/newest", "GET");
+            case 1:
+              return _context1.a(2, _t1(_context1.v).run);
+          }
+        }, _callee1);
+      }));
+      function newestCiRun() {
+        return _newestCiRun.apply(this, arguments);
+      }
+      return newestCiRun;
+    }()
+  };
+}
+
+/** A job's change that merges a proposal: `merge:<name>` (content's `mergeChange`). */
+function isMergeChange(change) {
+  return change.startsWith("merge:");
+}
+
+/** `/publish-jobs/:id/merge-prepare`'s answer: the merge's files, from content. */
+var MergePrepareAnswer = zod.z.object({
+  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()),
+    /*
+     * A merge that changes only content goes live on the live build, and
+     * this tab builds nothing (valbuild/home `docs/hosted-publishing.md`,
+     * step 8). Dropped by an object that did not name it, and the tab then
+     * read a job nobody builds as one it had lost.
+     */
+    contentOnly: zod.z.literal(true).optional()
+  }).nullable(),
+  sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()),
+  /*
+   * The proposal's own build target, when it changed the dependencies. Read
+   * by `parseBuildTarget`, the one reading of a build target there is.
+   */
+  target: zod.z.unknown().optional()
+});
+
+/** `/api/val/publish-job-prepare`'s answer, checked: it crossed a network. */
+var preparedJob = zod.z.object({
+  sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()),
+  binaryFiles: zod.z.record(zod.z.string(), zod.z.string()),
+  binaryFilesUnread: zod.z.array(zod.z.string()),
+  branch: zod.z.string().nullable(),
+  buildable: zod.z["boolean"]().optional()
+});
+function parsePreparedJob(body) {
+  var job = protocol.parseJob(body, "POST /api/val/publish-job-prepare").job;
+  var parsed = preparedJob.safeParse(body);
+  if (!parsed.success) throw new Error("The server's publish prepare answered with something this Studio cannot read.");
+  var _parsed$data = parsed.data,
+    buildable = _parsed$data.buildable,
+    rest = protocol._objectWithoutProperties(_parsed$data, _excluded);
+  return createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({
+    job: job
+  }, rest), {}, {
+    buildable: buildable !== null && buildable !== void 0 ? buildable : true
+  });
+}
+
+/**
+ * A publish job, as the tab that holds it runs it: prepare, build, upload --
+ * and then it is content's (valbuild/home, docs/app-mode.md, "Publishing is a
+ * queued job"). Content runs verify and the seal, and "Live" arrives on the
+ * websocket, so a tab that closes after its upload costs nothing.
+ *
+ * The tab holds the job by a lease, renewed on a timer while it works. A
+ * renewal answered `false` means the job is no longer this tab's -- its lease
+ * lapsed and its requests went back to the queue, or it was cancelled -- and
+ * the tab stops: another tab, or this one's next job, will build it.
+ *
+ * Every step is reported by name, so a report retried after a lost answer
+ * does nothing twice, and a failure is reported as the step's: content counts
+ * the attempts and, after the last, fails the job with Try again.
+ */
+
+/** How often the tab renews its lease. Content's job lease is 30 s. */
+var RENEW_EVERY_MS = 10000;
+function runStudioJob(_x) {
+  return _runStudioJob.apply(this, arguments);
+}
+function _runStudioJob() {
+  _runStudioJob = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(options) {
+    var _options$renewEveryMs;
+    var client, job, tab, onPhase, lost, renewing, lostResult, _options$canBuild, _options$canBuild2, _options$canBuild3, _options$canBuild4, prepared, message, handed, deployed, _message, built, uploaded, _t;
+    return slicedToArray._regenerator().w(function (_context) {
+      while (1) switch (_context.p = _context.n) {
+        case 0:
+          client = options.client, job = options.job, tab = options.tab, onPhase = options.onPhase;
+          lost = false;
+          renewing = setInterval(function () {
+            client.renew(job.id, tab).then(function (renewed) {
+              if (!renewed) lost = true;
+            },
+            // A renewal that did not get through is not a lost job: the lease is
+            // 30 s and the next one may.
+            function () {});
+          }, (_options$renewEveryMs = options.renewEveryMs) !== null && _options$renewEveryMs !== void 0 ? _options$renewEveryMs : RENEW_EVERY_MS);
+          lostResult = {
+            status: "lost",
+            jobId: job.id
+          };
+          _context.p = 1;
+          onPhase({
+            kind: "preparing"
+          });
+          _context.p = 2;
+          _context.n = 3;
+          return client.prepare(job, tab);
+        case 3:
+          prepared = _context.v;
+          _context.n = 6;
+          break;
+        case 4:
+          _context.p = 4;
+          _t = _context.v;
+          /*
+           * 502 is content answering the prepare with a failure, which content
+           * has already counted as an attempt at the step. Anything else never
+           * reached it, so the tab reports it.
+           */
+          message = messageOf$1(_t);
+          if (_t instanceof StudioPublishError && _t.statusCode === 502) {
+            _context.n = 5;
+            break;
+          }
+          _context.n = 5;
+          return client.step(job.id, {
+            tab: tab,
+            step: "prepare",
+            ok: false,
+            message: message
+          })["catch"](function () {
+            return null;
+          });
+        case 5:
+          return _context.a(2, {
+            status: "failed",
+            jobId: job.id,
+            message: message
+          });
+        case 6:
+          if (!(lost || prepared.job === null)) {
+            _context.n = 7;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 7:
+          if (!(prepared.job.step === null)) {
+            _context.n = 8;
+            break;
+          }
+          return _context.a(2, createForOfIteratorHelper._objectSpread2({
+            status: "handed-off",
+            jobId: job.id,
+            built: false
+          }, prepared.job.contentOnly ? {
+            contentOnly: true
+          } : {}));
+        case 8:
+          if (!(prepared.job.step !== "build")) {
+            _context.n = 9;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 9:
+          if (!(options.buildsElsewhere && !((_options$canBuild = (_options$canBuild2 = options.canBuild) === null || _options$canBuild2 === void 0 ? void 0 : _options$canBuild2.call(options)) !== null && _options$canBuild !== void 0 ? _options$canBuild : true))) {
+            _context.n = 10;
+            break;
+          }
+          return _context.a(2, {
+            status: "needs-builder",
+            jobId: job.id
+          });
+        case 10:
+          if (!(!prepared.buildable || !((_options$canBuild3 = (_options$canBuild4 = options.canBuild) === null || _options$canBuild4 === void 0 ? void 0 : _options$canBuild4.call(options)) !== null && _options$canBuild3 !== void 0 ? _options$canBuild3 : true))) {
+            _context.n = 13;
+            break;
+          }
+          onPhase({
+            kind: "handing-off"
+          });
+          _context.n = 11;
+          return client.step(job.id, {
+            tab: tab,
+            step: "build",
+            ok: true,
+            noBuild: true
+          });
+        case 11:
+          handed = _context.v;
+          if (!(lost || handed === null || handed.step !== null)) {
+            _context.n = 12;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 12:
+          return _context.a(2, {
+            status: "handed-off",
+            jobId: job.id,
+            built: false
+          });
+        case 13:
+          _context.n = 14;
+          return options.deploy(prepared, function (phase) {
+            return onPhase({
+              kind: "deploying",
+              phase: phase
+            });
+          });
+        case 14:
+          deployed = _context.v;
+          if (!lost) {
+            _context.n = 15;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 15:
+          if (!(deployed.status !== "uploaded")) {
+            _context.n = 17;
+            break;
+          }
+          _message = deployed.status === "failed" ? deployed.message : "The build went further than a job's build should.";
+          /*
+           * With the reason: if the build fails for good, content's failure is
+           * what every Studio shows, and without it that said "build failed 3
+           * times" and nothing else.
+           */
+          _context.n = 16;
+          return client.step(job.id, {
+            tab: tab,
+            step: "build",
+            ok: false,
+            message: _message
+          })["catch"](function () {
+            return null;
+          });
+        case 16:
+          return _context.a(2, {
+            status: "failed",
+            jobId: job.id,
+            message: _message
+          });
+        case 17:
+          onPhase({
+            kind: "handing-off"
+          });
+          _context.n = 18;
+          return client.step(job.id, {
+            tab: tab,
+            step: "build",
+            ok: true,
+            build: deployed.publishId
+          });
+        case 18:
+          built = _context.v;
+          if (!(built === null || built.step !== "upload")) {
+            _context.n = 19;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 19:
+          _context.n = 20;
+          return client.step(job.id, {
+            tab: tab,
+            step: "upload",
+            ok: true
+          });
+        case 20:
+          uploaded = _context.v;
+          if (!(lost || uploaded === null || uploaded.step !== null)) {
+            _context.n = 21;
+            break;
+          }
+          return _context.a(2, lostResult);
+        case 21:
+          return _context.a(2, {
+            status: "handed-off",
+            jobId: job.id,
+            built: true
+          });
+        case 22:
+          _context.p = 22;
+          clearInterval(renewing);
+          return _context.f(22);
+        case 23:
+          return _context.a(2);
+      }
+    }, _callee, null, [[2, 4], [1,, 22, 23]]);
+  }));
+  return _runStudioJob.apply(this, arguments);
+}
+var messageOf$1 = function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+};
+
+/**
+ * How many times one job is built in a row. Content counts the attempts at a
+ * step and fails the job after its last (`MAX_STEP_ATTEMPTS`, 3), so this is
+ * only a backstop for failures content never heard about.
+ */
+var MAX_RUNS = 5;
+
+/**
+ * Run a job until this tab's part of it is over: handed off, lost, or failed
+ * for good.
+ *
+ * A failed step is counted by content, which keeps the job at that step for
+ * the tab to run again -- until its last attempt, when it fails the job.
+ * Whether it is still this tab's is the renewal's answer, so a failure is
+ * followed by one, and a `true` runs it again.
+ */
+function runJobToEnd(_x2) {
+  return _runJobToEnd.apply(this, arguments);
+}
+function _runJobToEnd() {
+  _runJobToEnd = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2(options) {
+    var result, runs, again;
+    return slicedToArray._regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          result = {
+            status: "lost",
+            jobId: options.job.id
+          };
+          runs = 0;
+        case 1:
+          if (!(runs < MAX_RUNS)) {
+            _context2.n = 6;
+            break;
+          }
+          _context2.n = 2;
+          return options.run()["catch"](function (error) {
+            return {
+              status: "failed",
+              jobId: options.job.id,
+              message: messageOf$1(error)
+            };
+          });
+        case 2:
+          result = _context2.v;
+          if (!(result.status !== "failed")) {
+            _context2.n = 3;
+            break;
+          }
+          return _context2.a(2, result);
+        case 3:
+          _context2.n = 4;
+          return options.client.renew(options.job.id, options.tab)["catch"](function () {
+            return false;
+          });
+        case 4:
+          again = _context2.v;
+          if (again) {
+            _context2.n = 5;
+            break;
+          }
+          return _context2.a(2, result);
+        case 5:
+          runs++;
+          _context2.n = 1;
+          break;
+        case 6:
+          return _context2.a(2, result);
+      }
+    }, _callee2);
+  }));
+  return _runJobToEnd.apply(this, arguments);
+}
+
+/*
+ * Building a proposal's staged files and serving the build at its address:
+ * valbuild/home `docs/hosted-publishing.md`, step 7. The Studio builds one
+ * from its proposals bar, and home's upgrade page builds an upgrade's; each
+ * reaches content its own way, so the client is the caller's.
+ */
+
+/** A proposal as content answers it, as far as a build reads it. */
+
+/** The calls a build of a proposal makes. An error carries content's `status`. */
+
+/** The HTTP status an error carries, if it is an answer at all. */
+function statusOf(error) {
+  return createForOfIteratorHelper._typeof(error) === "object" && error !== null && "status" in error && typeof error.status === "number" ? error.status : null;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** What a build of the proposal came to. */
+
+/**
+ * Where a build of the proposal is, around the deploy: the deploy's own steps
+ * are the Studio's deploy state (`useStudioDeployState`), and these are the
+ * parts before and after it.
+ *
+ * - `reading`: the proposal's files and the target to build them on.
+ * - `deploying`: the deploy is running; its state says which step.
+ * - `serving`: content is putting the build up at the proposal's address.
+ * - `waiting`: that request did not come back -- a gateway gave up on it --
+ *   and content is asked until it says the proposal is built.
+ */
+
+/**
+ * Files that never go into a build: lockfiles, at any depth. The same list as
+ * content's `NEVER_SHIPPED` (valbuild/home `content/src/val/dependencyFiles.ts`).
+ *
+ * A merge builds from the site's source with the proposal's files over it,
+ * without these (`shippedFiles` there). The proposal's own build has to be
+ * made of the same files, or the two are named differently: a merge then
+ * never finds the proposal's build held, and builds the whole site again --
+ * which is every upgrade, since an upgrade stages a `pnpm-lock.yaml`.
+ */
+var NEVER_SHIPPED = new Set(["pnpm-lock.yaml", "pnpm-workspace.yaml", "package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "bun.lock", "bun.lockb"]);
+function withoutLockfiles(files) {
+  return Object.fromEntries(Object.entries(files).filter(function (_ref) {
+    var _ref2 = slicedToArray._slicedToArray(_ref, 1),
+      path = _ref2[0];
+    return !NEVER_SHIPPED.has(path.slice(path.lastIndexOf("/") + 1));
+  }));
+}
+
+/**
+ * Whether serving got no answer from content rather than a refusal: the
+ * connection failed, or a gateway stopped waiting -- Cloudflare's 52x (524 is
+ * "no answer in 100 seconds"), and the 502-504 of anything else in between.
+ * Content goes on with the request either way, so the build may well be
+ * served.
+ */
+function gatewayGaveUp(error) {
+  // No answer at all: `fetch` rejects with a TypeError when the connection
+  // fails or is cut. Anything else is a failure with words of its own.
+  if (error instanceof TypeError) return true;
+  var status = statusOf(error);
+  if (status === null) return false;
+  return status === 502 || status === 503 || status === 504 || status >= 520 && status <= 527;
+}
+
+/** How long, and how often, content is asked whether it served the build. */
+var SERVE_WAIT_MS = 4 * 60000;
+var SERVE_POLL_MS = 5000;
+
+/**
+ * Build the proposal's staged files and serve the build at its address.
+ *
+ * The files and what they are for (`inputs`) come in one answer, so the build
+ * names exactly what it was made of; content refuses it if they were staged
+ * again meanwhile. The tab builds as for a publish and stops once the build is
+ * uploaded -- nothing goes live -- and content hands it to the platform.
+ *
+ * Serving can take longer than a gateway waits for an answer, and content
+ * finishes it all the same. So a gateway that gives up is not a failure: the
+ * proposal is read until it says it is built from these inputs, and served
+ * once more only if it never does.
+ */
+function buildProposal(_x) {
+  return _buildProposal.apply(this, arguments);
+}
+function _buildProposal() {
+  _buildProposal = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee3(deps) {
+    var _deps$now, _deps$sleep, _deps$onStep;
+    var now, sleep, step, read, _read, files, staged, inputs, target, asked, built, serve, servedNow, builtOf, since, served, _t2, _t3, _t4, _t5, _t6, _t7;
+    return slicedToArray._regenerator().w(function (_context3) {
+      while (1) switch (_context3.p = _context3.n) {
+        case 0:
+          now = (_deps$now = deps.now) !== null && _deps$now !== void 0 ? _deps$now : Date.now;
+          sleep = (_deps$sleep = deps.sleep) !== null && _deps$sleep !== void 0 ? _deps$sleep : function (ms) {
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, ms);
+            });
+          };
+          step = (_deps$onStep = deps.onStep) !== null && _deps$onStep !== void 0 ? _deps$onStep : function () {};
+          if (deps.canBuildHere()) {
+            _context3.n = 1;
+            break;
+          }
+          return _context3.a(2, {
+            status: "failed",
+            message: "This browser cannot build in this tab. Open the proposal in Chrome, Edge or Firefox and build it there"
+          });
+        case 1:
+          step({
+            kind: "reading"
+          });
+          _context3.p = 2;
+          _context3.n = 3;
+          return deps.client.files(deps.name);
+        case 3:
+          read = _context3.v;
+          _context3.n = 5;
+          break;
+        case 4:
+          _context3.p = 4;
+          _t2 = _context3.v;
+          return _context3.a(2, {
+            status: "failed",
+            message: messageOf(_t2)
+          });
+        case 5:
+          _read = read, files = _read.files, staged = _read.staged;
+          if (!(staged.inputs === null)) {
+            _context3.n = 6;
+            break;
+          }
+          return _context3.a(2, {
+            status: "nothing-staged"
+          });
+        case 6:
+          if (staged.buildRequired) {
+            _context3.n = 7;
+            break;
+          }
+          return _context3.a(2, {
+            status: "already-built",
+            hash: null
+          });
+        case 7:
+          inputs = staged.inputs;
+          _context3.p = 8;
+          _context3.n = 9;
+          return deps.client.buildTarget(deps.name);
+        case 9:
+          asked = _context3.v;
+          target = asked.layer === "own" ? asked.target : undefined;
+          _context3.n = 11;
+          break;
+        case 10:
+          _context3.p = 10;
+          _t3 = _context3.v;
+          if (!(statusOf(_t3) !== 404)) {
+            _context3.n = 11;
+            break;
+          }
+          return _context3.a(2, {
+            status: "failed",
+            message: messageOf(_t3)
+          });
+        case 11:
+          step({
+            kind: "deploying"
+          });
+          _context3.n = 12;
+          return deps.deploy(withoutLockfiles(files), target);
+        case 12:
+          built = _context3.v;
+          if (!(built.status !== "uploaded")) {
+            _context3.n = 13;
+            break;
+          }
+          return _context3.a(2, {
+            status: "failed",
+            message: built.status === "failed" ? built.message : "The build went live instead of stopping once uploaded."
+          });
+        case 13:
+          serve = /*#__PURE__*/function () {
+            var _ref3 = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee() {
+              return slicedToArray._regenerator().w(function (_context) {
+                while (1) switch (_context.n) {
+                  case 0:
+                    step({
+                      kind: "serving",
+                      since: now()
+                    });
+                    return _context.a(2, deps.client.serveBuild(deps.name, {
+                      publishId: built.publishId,
+                      inputs: inputs
+                    }));
+                }
+              }, _callee);
+            }));
+            return function serve() {
+              return _ref3.apply(this, arguments);
+            };
+          }();
+          servedNow = /*#__PURE__*/function () {
+            var _ref4 = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2() {
+              var _proposal$staged, _proposal$built, proposal;
+              return slicedToArray._regenerator().w(function (_context2) {
+                while (1) switch (_context2.p = _context2.n) {
+                  case 0:
+                    _context2.p = 0;
+                    _context2.n = 1;
+                    return deps.client.get(deps.name);
+                  case 1:
+                    proposal = _context2.v;
+                    return _context2.a(2, ((_proposal$staged = proposal.staged) === null || _proposal$staged === void 0 ? void 0 : _proposal$staged.inputs) === inputs && proposal.staged.buildRequired === false && (_proposal$built = proposal.built) !== null && _proposal$built !== void 0 && _proposal$built.hash ? proposal : null);
+                  case 2:
+                    _context2.p = 2;
+                    _context2.v;
+                    return _context2.a(2, null);
+                }
+              }, _callee2, null, [[0, 2]]);
+            }));
+            return function servedNow() {
+              return _ref4.apply(this, arguments);
+            };
+          }();
+          builtOf = function builtOf(proposal) {
+            var _proposal$built$hash, _proposal$built2;
+            return {
+              status: "built",
+              hash: (_proposal$built$hash = (_proposal$built2 = proposal.built) === null || _proposal$built2 === void 0 ? void 0 : _proposal$built2.hash) !== null && _proposal$built$hash !== void 0 ? _proposal$built$hash : null,
+              proposal: proposal
+            };
+          };
+          _context3.p = 14;
+          _t4 = builtOf;
+          _context3.n = 15;
+          return serve();
+        case 15:
+          return _context3.a(2, _t4(_context3.v));
+        case 16:
+          _context3.p = 16;
+          _t5 = _context3.v;
+          if (gatewayGaveUp(_t5)) {
+            _context3.n = 17;
+            break;
+          }
+          return _context3.a(2, {
+            status: "failed",
+            message: messageOf(_t5)
+          });
+        case 17:
+          since = now();
+          step({
+            kind: "waiting",
+            since: since
+          });
+        case 18:
+          if (!(now() - since < SERVE_WAIT_MS)) {
+            _context3.n = 22;
+            break;
+          }
+          _context3.n = 19;
+          return sleep(SERVE_POLL_MS);
+        case 19:
+          _context3.n = 20;
+          return servedNow();
+        case 20:
+          served = _context3.v;
+          if (!(served !== null)) {
+            _context3.n = 21;
+            break;
+          }
+          return _context3.a(2, builtOf(served));
+        case 21:
+          _context3.n = 18;
+          break;
+        case 22:
+          _context3.p = 22;
+          _t6 = builtOf;
+          _context3.n = 23;
+          return serve();
+        case 23:
+          return _context3.a(2, _t6(_context3.v));
+        case 24:
+          _context3.p = 24;
+          _t7 = _context3.v;
+          return _context3.a(2, {
+            status: "failed",
+            message: messageOf(_t7)
+          });
+      }
+    }, _callee3, null, [[22, 24], [14, 16], [8, 10], [2, 4]]);
+  }));
+  return _buildProposal.apply(this, arguments);
+}
+
+exports.proposalProject = proposalProject.proposalProject;
+exports.MergePrepareAnswer = MergePrepareAnswer;
+exports.RENEW_EVERY_MS = RENEW_EVERY_MS;
+exports.SERVE_POLL_MS = SERVE_POLL_MS;
+exports.SERVE_WAIT_MS = SERVE_WAIT_MS;
+exports.STUDIO_OUT_OF_DATE = STUDIO_OUT_OF_DATE;
+exports.STUDIO_OUT_OF_DATE_MESSAGE = STUDIO_OUT_OF_DATE_MESSAGE;
+exports.StudioPublishError = StudioPublishError;
+exports.StudioUploadError = StudioUploadError;
+exports.buildProposal = buildProposal;
+exports.callJson = callJson;
+exports.carriedInto = carriedInto;
+exports.createStudioJobClient = createStudioJobClient;
+exports.createStudioPublishClient = createStudioPublishClient;
+exports.isExpiredSlot = isExpiredSlot;
+exports.isMergeChange = isMergeChange;
+exports.isTransientPublishError = isTransientPublishError;
+exports.layerMoved = layerMoved;
+exports.loadedLayer = loadedLayer;
+exports.markStudioOutOfDate = markStudioOutOfDate;
+exports.onPublishRefusal = onPublishRefusal;
+exports.publishApiOf = publishApiOf;
+exports.readLiveLayer = readLiveLayer;
+exports.rememberLoadedLayer = rememberLoadedLayer;
+exports.resetLoadedLayerForTests = resetLoadedLayerForTests;
+exports.runJobToEnd = runJobToEnd;
+exports.runStudioDeploy = runStudioDeploy;
+exports.runStudioJob = runStudioJob;
+exports.runStudioPublish = runStudioPublish;
+exports.siteMovedSinceLoad = siteMovedSinceLoad;
+exports.splitBinaryFiles = splitBinaryFiles;
+exports.studioOutOfDateRefusals = studioOutOfDateRefusals;
+exports.subscribeStudioOutOfDate = subscribeStudioOutOfDate;
+exports.withCommittedFiles = withCommittedFiles;
+exports.withoutLockfiles = withoutLockfiles;