@valbuild/shared 0.134.1 → 0.136.1

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 {
@@ -1864,6 +1920,27 @@ var Api = {
           profileId: zod.z.string().nullable(),
           mode: zod.z.union([zod.z.literal("http"), zod.z.literal("fs")]),
           jsonEntriesSha: zod.z.string().optional(),
+          /**
+           * How this project's SOURCE is kept, when the server knows.
+           *
+           * `"managed"` -- the content service is the store of record,
+           * there is no repository, and the Studio is the deployer: the
+           * build that makes a publish live happens in the tab that started
+           * it. `"connected"` -- commits are mirrored into a repository a
+           * host watches, so something outside the browser finishes the
+           * job.
+           *
+           * The Studio narrates a publish differently for each, because a
+           * `building` state in managed mode is a spinner with no event
+           * that can ever end it -- not on a reload, not on a retry, not
+           * tomorrow.
+           *
+           * Optional, and absent means "not reported", never "managed":
+           * `fs` mode has no project to have a mode, and so does an `http`
+           * server that predates the field. Both keep the connected story,
+           * which is the one the Studio has always told.
+           */
+          sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
           publishRefusal: PublishRefusal.optional()
         }), zod.z.object({
           type: zod.z.literal("use-websocket"),
@@ -1926,12 +2003,113 @@ var Api = {
           config: ValConfig,
           profileId: zod.z.string().nullable(),
           mode: zod.z.union([zod.z.literal("http"), zod.z.literal("fs")]),
+          /**
+           * How this project's SOURCE is kept, when the server knows.
+           *
+           * `"managed"` -- the content service is the store of record,
+           * there is no repository, and the Studio is the deployer: the
+           * build that makes a publish live happens in the tab that started
+           * it. `"connected"` -- commits are mirrored into a repository a
+           * host watches, so something outside the browser finishes the
+           * job.
+           *
+           * The Studio narrates a publish differently for each, because a
+           * `building` state in managed mode is a spinner with no event
+           * that can ever end it -- not on a reload, not on a retry, not
+           * tomorrow.
+           *
+           * Optional, and absent means "not reported", never "managed":
+           * `fs` mode has no project to have a mode, and so does an `http`
+           * server that predates the field. Both keep the connected story,
+           * which is the one the Studio has always told.
+           */
+          sourceMode: zod.z.union([zod.z.literal("managed"), zod.z.literal("connected")]).optional(),
           publishRefusal: PublishRefusal.optional()
         })])
       })])
     }
   },
   // 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: {
@@ -2413,6 +2591,21 @@ 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(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -6762,6 +6955,312 @@ 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()
+});
+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;
@@ -6808,6 +7307,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;
@@ -6891,7 +7391,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;