@valbuild/shared 0.136.0 → 0.136.2

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@valbuild/core');
-var getSitemapTree = require('../../dist/getSitemapTree-99839b02.cjs.prod.js');
+var getSitemapTree = require('../../dist/getSitemapTree-0ed3deac.cjs.prod.js');
 var zod = require('zod');
 var zodValidationError = require('zod-validation-error');
 var FlexSearch = require('flexsearch');
@@ -661,6 +661,62 @@ var VAL_SESSION_COOKIE = core.Internal.VAL_SESSION_COOKIE;
 var VAL_STATE_COOKIE = core.Internal.VAL_STATE_COOKIE;
 var VAL_ENABLE_COOKIE_NAME = core.Internal.VAL_ENABLE_COOKIE_NAME;
 
+/**
+ * One value, computed once per REQUEST.
+ *
+ * `fetchVal` in draft mode reads the whole module tree out of `/sources/~`, and
+ * a page that calls it three times used to ask three times — the answer being
+ * byte-identical each time, because the query and the session are fixed for the
+ * length of a request. This is what makes the second and third call free.
+ *
+ * ## Why the scope is the REQUEST and can never be wider
+ *
+ * The memoised response is `own_patch_groups_only: true` — it contains the
+ * CALLER'S OWN unpublished work, resolved from their session cookie. A memo
+ * that outlived the request would serve one author's staged edits to the next
+ * visitor, which is the exact failure `own_patch_groups_only` exists to
+ * prevent, and it would be invisible: the draft would simply render somebody
+ * else's half-finished sentence.
+ *
+ * So this module holds NO state of its own. The caller supplies the box, and
+ * the box has to come from something the framework already scopes to the
+ * request — React's `cache()` in an RSC, a `WeakMap` keyed on the `Request` in
+ * TanStack Start. `null` means "no request scope available", and that is not an
+ * error: it falls back to computing every time, which is what the code did
+ * before this existed. Ineffective is a safe failure here; leaking is not.
+ *
+ * The `key` is the second half of that guarantee. It carries whatever the
+ * answer depends on — the session — so a box that somehow outlived its request,
+ * or is shared by two sessions, MISSES rather than serving the wrong draft.
+ *
+ * ## The promise is cached, not the value
+ *
+ * React renders siblings concurrently, so three `fetchVal` calls in one page
+ * are usually in flight at the same time rather than one after another.
+ * Caching the resolved value would dedupe none of them; caching the promise
+ * dedupes both orderings.
+ */
+
+/**
+ * Returns the memoised promise for `key`, computing it only on a miss.
+ *
+ * A rejection is memoised along with everything else, on purpose: one failed
+ * read per request is the same answer for every caller in it, and retrying it
+ * two more times only makes a broken draft slower to render.
+ */
+function memoizePerRequest(box, key, compute) {
+  if (box === null) {
+    return compute();
+  }
+  if (box.promise !== undefined && box.key === key) {
+    return box.promise;
+  }
+  var promise = compute();
+  box.key = key;
+  box.promise = promise;
+  return promise;
+}
+
 function _regeneratorDefine(e, r, n, t) {
   var i = Object.defineProperty;
   try {
@@ -1974,6 +2030,86 @@ var Api = {
     }
   },
   // This has a path which is like this: /upload/patches/:patchId/files. Example: /upload/patches/76b9237a-7712-4d60-88b4-d273e6d6fe18/files
+  /**
+   * The content service's publish API, reached through this deployment.
+   *
+   * A managed project is built in the Studio's own tab -- there is no host
+   * watching a repository to pick a commit up -- and what it builds then has to
+   * be published. The browser cannot do that itself: it holds a session cookie
+   * for this origin and no credential content would accept. So the publish
+   * conversation goes through here, exactly as patches already do.
+   *
+   * ## Deliberately not typed past this point
+   *
+   * No `res`, and a body this does not describe. The shapes belong to content,
+   * and they are already written down twice -- once in content's own `Api.ts`
+   * and once in the copy `@valbuild/cli` keeps beside its parser so the two can
+   * be diffed by eye. A third copy here would be a third thing to keep in step,
+   * and this layer has no decision to make that would need one: it authenticates
+   * the caller, swaps the credential, and carries status and body back verbatim.
+   * The Studio parses the answer with the same module the CLI does.
+   *
+   * That means this route answers with statuses the generic result type does not
+   * model -- a 409 when a publish has already gone live, for one. `/save` has
+   * always done the same; the dispatch boundary erases the type and the adapter
+   * sends what it is given.
+   *
+   * ## What it may reach
+   *
+   * The sub-path is content's, minus `/v1`: `/publish`, `/publish/{id}` and its
+   * three steps, and `/build-target`. `ValOpsHttp.publishApi` holds the allow
+   * list, beside the credential, because the browser chooses this path.
+   */
+  "/publish-api": {
+    GET: {
+      req: {
+        path: zod.z.string().optional(),
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      /*
+       * Content's status and body, carried through.
+       *
+       * Permissive on purpose: describing the shapes here would be the third
+       * copy of a contract content owns, and this layer reads none of them. A
+       * body that is not JSON -- a gateway's HTML error page -- arrives as
+       * `{ message }` rather than throwing, because a publish failing is
+       * something the editor has to be told about in words.
+       */
+      res: zod.z.object({
+        status: zod.z.number(),
+        json: zod.z.unknown()
+      })
+    },
+    POST: {
+      req: {
+        path: zod.z.string().optional(),
+        /*
+         * Unknown, and passed through unread. Every field content accepts here
+         * would otherwise have to be declared -- and kept in step -- by a layer
+         * that never looks at one.
+         */
+        body: zod.z.unknown().optional(),
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      /*
+       * Content's status and body, carried through.
+       *
+       * Permissive on purpose: describing the shapes here would be the third
+       * copy of a contract content owns, and this layer reads none of them. A
+       * body that is not JSON -- a gateway's HTML error page -- arrives as
+       * `{ message }` rather than throwing, because a publish failing is
+       * something the editor has to be told about in words.
+       */
+      res: zod.z.object({
+        status: zod.z.number(),
+        json: zod.z.unknown()
+      })
+    }
+  },
   "/upload/patches": {
     POST: {
       req: {
@@ -2455,6 +2591,49 @@ var Api = {
            * server that predates this.
            */
           commitSha: zod.z.string().optional(),
+          /**
+           * The source files this commit wrote, by path, for a MANAGED project.
+           *
+           * A managed project has nobody to deploy it, so the Studio builds
+           * the site in the tab -- and the build has to contain the text this
+           * commit just produced. Nothing else can give it that: the
+           * project's stored source is what the LAST build was made from, and
+           * turning patched Source back into `.val.ts` text happens here, on
+           * the server, not in a browser. `null` is a file the commit
+           * deleted.
+           *
+           * Absent for a connected project, whose host builds from the
+           * repository, and from a server that predates it.
+           */
+          sourceFiles: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
+          /**
+           * The binary files this commit wrote -- an image uploaded in the
+           * Studio -- base64, by path, for a MANAGED project.
+           *
+           * The same reason as `sourceFiles`: the in-tab build publishes the
+           * site, and a file this commit added is in no earlier build. Local
+           * files only; a remote one is served from its own URL and was never
+           * part of a build. A deleted file is a `null` in `sourceFiles`, as
+           * it always was.
+           */
+          binaryFiles: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+          /**
+           * The branch this commit is on, for a MANAGED project -- the
+           * content service's word for it.
+           *
+           * The in-tab build has to name the branch it was made at, and its
+           * only other source is the `val.server.ts` the last build was
+           * wired with: a project cloned from a template seed has one wired
+           * at no commit, so without this its first publish is branchless
+           * and the loader refuses it.
+           */
+          branch: zod.z.string().optional(),
+          /**
+           * Binary files this commit wrote whose bytes the server could not
+           * read back before committing. Named so the Studio refuses to build
+           * a site that would 404 them, rather than publishing it.
+           */
+          binaryFilesUnread: zod.z.array(zod.z.string()).optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -6804,6 +6983,342 @@ function resolvePairGround(ground, ramp) {
   return typeof ground === "number" ? ramp[ground] : ground;
 }
 
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, getSitemapTree._toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
+}
+
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
+}
+
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+
+/**
+ * Reading what content answers.
+ *
+ * Every type here comes from `contentApi.ts`, which is a copy of the
+ * service's own `Api.ts` - so the shapes are not re-derived from what this end
+ * wishes it received, and a copy brought up to date fails to compile wherever
+ * this CLI has not caught up.
+ *
+ * The schemas are the runtime half, and they are needed as well as the types:
+ * what arrives is JSON over HTTP from a service that versions separately, so a
+ * type alone asserts a shape rather than checking one. Each schema is
+ * annotated with the copied type it must produce (`z.ZodType<DeclareResponse>`
+ * and so on), which is what ties the two halves together - a schema that drifts
+ * from the copy does not compile, and an answer that drifts from the schema
+ * does not parse. `ValOpsHttp` in `@valbuild/server` reads every other content
+ * route the same way.
+ *
+ * Nothing here is laxer than the copy. An optional field is optional because
+ * the service says so; making a required one optional here would hide exactly
+ * the drift this file exists to catch.
+ */
+
+/** An artifact, as it is declared: by key, by hash, by size. */
+
+/** Permission to write one artifact's bytes to object storage. */
+
+var publishState = zod.z["enum"](["awaiting-artifacts", "ready", "verified", "live", "failed", "expired"]);
+var publishProblem = zod.z.object({
+  code: zod.z.string(),
+  message: zod.z.string(),
+  hint: zod.z.string().optional(),
+  keys: zod.z.array(zod.z.string()).optional()
+});
+var uploadSlot = zod.z.object({
+  key: zod.z.string(),
+  url: zod.z.string(),
+  method: zod.z.literal("PUT"),
+  headers: zod.z.record(zod.z.string(), zod.z.string()),
+  expiresAt: zod.z.string()
+});
+var declareResponse = zod.z.object({
+  publishId: zod.z.string(),
+  state: publishState,
+  project: zod.z.object({
+    publicProjectId: zod.z.string(),
+    siteUrl: zod.z.string().nullable()
+  }),
+  uploads: zod.z.array(uploadSlot),
+  have: zod.z.array(zod.z.string())
+});
+var artifactsResponse = zod.z.object({
+  state: publishState,
+  problems: zod.z.array(publishProblem)
+});
+var verifyResponse = zod.z.object({
+  state: publishState,
+  ok: zod.z["boolean"](),
+  previewUrl: zod.z.string().nullable(),
+  problems: zod.z.array(publishProblem)
+});
+var promoteResponse = zod.z.object({
+  state: publishState,
+  url: zod.z.string().nullable(),
+  commit: zod.z.string().nullable()
+});
+var statusResponse = zod.z.object({
+  publishId: zod.z.string(),
+  state: publishState,
+  buildHash: zod.z.string(),
+  missing: zod.z.array(zod.z.string()),
+  problems: zod.z.array(publishProblem)
+});
+var publishTokenResponse = zod.z.object({
+  token: zod.z.string(),
+  expiresAt: zod.z.string().nullable(),
+  publicProjectId: zod.z.string(),
+  productionUrl: zod.z.string().nullable()
+});
+
+/**
+ * Content answered, and the answer was not one this CLI can act on.
+ *
+ * Separate from a refusal, which is content saying no in a sentence meant for
+ * a person. This is two programs disagreeing - the copy in `contentApi.ts` and
+ * the service that has moved on from it - and the two want opposite things
+ * said about them.
+ */
+var PublishProtocolError = /*#__PURE__*/function (_Error) {
+  function PublishProtocolError(message) {
+    var _this;
+    _classCallCheck(this, PublishProtocolError);
+    _this = _callSuper(this, PublishProtocolError, [message]);
+    _this.name = "PublishProtocolError";
+    return _this;
+  }
+  _inherits(PublishProtocolError, _Error);
+  return _createClass(PublishProtocolError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var parseDeclare = function parseDeclare(body) {
+  return parse(declareResponse, body, "POST /v1/publish");
+};
+var parseArtifacts = function parseArtifacts(body) {
+  return parse(artifactsResponse, body, "POST /v1/publish/{id}/artifacts");
+};
+var parseVerify = function parseVerify(body) {
+  return parse(verifyResponse, body, "POST /v1/publish/{id}/verify");
+};
+var parsePromote = function parsePromote(body) {
+  return parse(promoteResponse, body, "POST /v1/publish/{id}/promote");
+};
+var parseStatus = function parseStatus(body) {
+  return parse(statusResponse, body, "GET /v1/publish/{id}");
+};
+var parsePublishToken = function parsePublishToken(body, call) {
+  return parse(publishTokenResponse, body, call);
+};
+
+/**
+ * What a build targets, and the project's files, as the Studio asks for them.
+ *
+ * Both are read through `/publish-api` rather than fetched from the loader,
+ * because a browser has neither the loader's address nor a credential it would
+ * accept. `fetchBuildTarget` in `@valbuild/tanstack-build` is the other half --
+ * same shape, a different caller, and it CASTS where this parses.
+ *
+ * Parsed rather than cast here because of what sits in between: a proxy, a
+ * gateway and a service boundary. An HTML error page cast to `BuildTarget`
+ * fails several layers down inside rolldown with a message about a module
+ * specifier, and the publish that follows would label a build against a layer
+ * that was never there.
+ *
+ * The TYPE is inferred from this schema instead of imported. `BuildTarget` is
+ * declared in `@valbuild/tanstack-build`, which has no zod and deliberately
+ * almost no dependencies -- it goes into a browser bundle -- and this package
+ * is imported by everything. The declarations are kept honest at the one place
+ * the value is used: it is passed straight into `buildUserApp({ target })`, so
+ * a drift between them is a compile error at that call rather than a runtime
+ * surprise.
+ */
+var buildTargetResponse = zod.z.object({
+  base: zod.z.object({
+    rev: zod.z.string(),
+    shellRev: zod.z.string(),
+    rscShellRev: zod.z.string(),
+    modules: zod.z.record(zod.z.string(), zod.z.string()),
+    rscModules: zod.z.record(zod.z.string(), zod.z.string()),
+    paths: zod.z.object({
+      baseFromProject: zod.z.string(),
+      projectVendorDir: zod.z.string(),
+      rscVendorBase: zod.z.string(),
+      rscRuntimeSpecifier: zod.z.string(),
+      rscRuntimePath: zod.z.string(),
+      flightServer: zod.z.string(),
+      serverFnBase: zod.z.string()
+    })
+  }),
+  project: zod.z.object({
+    rev: zod.z.string().nullable(),
+    rsc: zod.z["boolean"](),
+    modules: zod.z.record(zod.z.string(), zod.z.string()),
+    css: zod.z.record(zod.z.string(), zod.z.string()),
+    workerOnly: zod.z.array(zod.z.string())
+  })
+});
+/**
+ * `null` files is a real answer: a project that has never published.
+ *
+ * Distinguished from an empty record, which would be a project that published
+ * nothing -- and which a build would take as "no entry point" rather than as
+ * "there is nothing here yet".
+ */
+var projectSourceResponse = zod.z.object({
+  files: zod.z.record(zod.z.string(), zod.z.string()).nullable(),
+  /**
+   * The live build's `public/*` artifacts, by hash -- what a publisher with no
+   * checkout carries into its build so the site keeps its favicon and images.
+   *
+   * The loader stores public files PER BUILD, so a build that names none
+   * serves none. A publisher with a checkout has them on disk; the Studio has
+   * this. Re-declaring one costs nothing: content holds the bytes for the
+   * project already and asks for no upload.
+   *
+   * `null` when content cannot say -- the live build was not published through
+   * it -- and absent from a content service that predates it. A publisher
+   * must treat both as "unknown", never as "none": publishing on that guess
+   * deletes every public file the site has.
+   */
+  publicFiles: zod.z.array(zod.z.object({
+    key: zod.z.string(),
+    sha256: zod.z.string(),
+    bytes: zod.z.number()["int"]().nonnegative()
+  })).nullable().optional(),
+  /**
+   * The URL paths the live build serves from `public/`, as the loader has
+   * them -- without the bytes' hashes.
+   *
+   * The fallback for when `publicFiles` is `null`: a build content has no
+   * record of, which is every project cloned from a template seed. A publisher
+   * running on the site's own origin can fetch these and build with them;
+   * after that publish content holds their hashes and `publicFiles` answers.
+   * `null` when the loader serves no build or does not say.
+   */
+  publicPaths: zod.z.array(zod.z.string()).nullable().optional()
+});
+var parseBuildTarget = function parseBuildTarget(body) {
+  return parse(buildTargetResponse, body, "GET /v1/build-target");
+};
+var parseProjectSource = function parseProjectSource(body) {
+  return parse(projectSourceResponse, body, "GET /v1/project-source");
+};
+
+/**
+ * The `details` of a refusal, when it carries a list of problems.
+ *
+ * Every non-2xx is `{ statusCode, message, details? }`, and the publish routes
+ * put `PublishProblem[]` in `details` - a declaration is answered with EVERY
+ * problem rather than the first, because finding them one round trip at a time
+ * is how a publish takes six attempts. Anything else in there is somebody
+ * else's `details` and is left to the caller's own message.
+ */
+function parseProblems(details) {
+  var parsed = zod.z.array(publishProblem).safeParse(details);
+  return parsed.success ? parsed.data : [];
+}
+function parse(schema, body, call) {
+  var parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new PublishProtocolError("".concat(call, " answered with something this publisher cannot read: ").concat(zodValidationError.fromError(parsed.error).toString()));
+  }
+  return parsed.data;
+}
+
 exports.DEFAULT_CANVAS_SELECTION = getSitemapTree.DEFAULT_CANVAS_SELECTION;
 exports.DEFAULT_CANVAS_SELECTION_SOFT = getSitemapTree.DEFAULT_CANVAS_SELECTION_SOFT;
 exports.VAL_AI_SESSION_STORAGE_KEY = getSitemapTree.VAL_AI_SESSION_STORAGE_KEY;
@@ -6850,6 +7365,7 @@ exports.PatchBlock = PatchBlock;
 exports.PatchGroup = PatchGroup;
 exports.PatchId = PatchId;
 exports.PatchJSON = PatchJSON;
+exports.PublishProtocolError = PublishProtocolError;
 exports.RAMP_STEPS = RAMP_STEPS;
 exports.RemirrorBr = RemirrorBr;
 exports.RemirrorBulletList = RemirrorBulletList;
@@ -6933,7 +7449,17 @@ exports.isSkippedSource = isSkippedSource;
 exports.keyOfRecordPath = keyOfRecordPath;
 exports.levenshtein = levenshtein;
 exports.localeAt = localeAt;
+exports.memoizePerRequest = memoizePerRequest;
 exports.newestCommitSha = newestCommitSha;
+exports.parseArtifacts = parseArtifacts;
+exports.parseBuildTarget = parseBuildTarget;
+exports.parseDeclare = parseDeclare;
+exports.parseProblems = parseProblems;
+exports.parseProjectSource = parseProjectSource;
+exports.parsePromote = parsePromote;
+exports.parsePublishToken = parsePublishToken;
+exports.parseStatus = parseStatus;
+exports.parseVerify = parseVerify;
 exports.partitionValidationErrors = partitionValidationErrors;
 exports.performSearch = performSearch;
 exports.relativeLuminance = relativeLuminance;