@valbuild/shared 0.120.0 → 0.121.0

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

@@ -1333,6 +1333,21 @@ var notFoundResponse = zod.z.object({
 var GenericError = zod.z.object({
   message: zod.z.string()
 });
+
+/**
+ * A patch group: the set of patches one user has chosen to publish.
+ *
+ * Not a patch *set* — a patch set is computed from the schema and says which
+ * patches must move together; a patch group is curated and says which ones this
+ * user wants live. See `docs/independent-publish/PLAN.md`.
+ */
+var PatchGroup = zod.z.object({
+  patchGroupId: zod.z.string(),
+  authorId: zod.z.string().nullable(),
+  createdAt: zod.z.string(),
+  publishedAt: zod.z.string().nullable(),
+  patchIds: zod.z.array(PatchId)
+});
 var GenericPatchError = zod.z.union([zod.z.object({
   patchId: PatchId,
   message: zod.z.string()
@@ -1714,6 +1729,30 @@ var Api = {
           schemaSha: zod.z.string(),
           sourcesSha: zod.z.string(),
           patches: zod.z.array(PatchId),
+          /**
+           * Of `patches`, the ones that have already SHIPPED.
+           *
+           * A published patch stays in the chain with `appliedAt` set until
+           * the next deployment moves the base, so the id list alone cannot
+           * say which is which — and a client never re-fetches a record it
+           * already holds, so it never finds out on its own. Another
+           * author's publish then left that patch pending in your scope,
+           * your prefix gate read a hole in front of it, and Publish
+           * refused for a reason that had stopped being true.
+           *
+           * Optional: `fs` mode forgets published patches outright, and a
+           * client that ignores this behaves exactly as it did before.
+           */
+          appliedPatches: zod.z.array(PatchId).optional(),
+          /**
+           * The newest commit, which is the PUBLISH head.
+           *
+           * Not `commitSha`: that is the commit this deployment serves and
+           * moves only when a new build lands. This moves the instant
+           * somebody publishes, which is what makes it the thing a client
+           * carries back to `/save` to say which world it decided against.
+           */
+          headCommitSha: zod.z.string().optional(),
           /**
            * Unpublished changes the store threw away because it could not
            * read them.
@@ -1742,6 +1781,30 @@ var Api = {
           sourcesSha: zod.z.string(),
           commitSha: zod.z.string(),
           patches: zod.z.array(PatchId),
+          /**
+           * Of `patches`, the ones that have already SHIPPED.
+           *
+           * A published patch stays in the chain with `appliedAt` set until
+           * the next deployment moves the base, so the id list alone cannot
+           * say which is which — and a client never re-fetches a record it
+           * already holds, so it never finds out on its own. Another
+           * author's publish then left that patch pending in your scope,
+           * your prefix gate read a hole in front of it, and Publish
+           * refused for a reason that had stopped being true.
+           *
+           * Optional: `fs` mode forgets published patches outright, and a
+           * client that ignores this behaves exactly as it did before.
+           */
+          appliedPatches: zod.z.array(PatchId).optional(),
+          /**
+           * The newest commit, which is the PUBLISH head.
+           *
+           * Not `commitSha`: that is the commit this deployment serves and
+           * moves only when a new build lands. This moves the instant
+           * somebody publishes, which is what makes it the thing a client
+           * carries back to `/save` to say which world it decided against.
+           */
+          headCommitSha: zod.z.string().optional(),
           commits: zod.z.array(ValCommit),
           config: ValConfig,
           profileId: zod.z.string().nullable(),
@@ -1811,6 +1874,26 @@ var Api = {
         query: {
           id: zod.z.array(PatchId).min(1, "At least one patch id is required")
         },
+        body: zod.z.object({
+          /*
+           * Patches that are NOT being deleted but must lose their patch
+           * group membership because these are.
+           *
+           * Deleting a patch out of the middle of a patch set leaves every
+           * group holding the rest with a non-prefix intersection, and a
+           * prefix is the one invariant a group has. Which patches those are
+           * needs the content schema, so the client computes the forward
+           * closure and sends it; the content API drops the memberships
+           * without touching the patches.
+           *
+           * In the BODY while the ids to delete are in the query, because
+           * this list is unbounded in the same way and the query string is
+           * already chunked to fit. Optional throughout: `fs` mode has no
+           * groups, and a client that predates this is deleting correctly,
+           * just not repairing.
+           */
+          unstagePatchIds: zod.z.array(PatchId).optional()
+        }).optional(),
         cookies: {
           val_session: zod.z.string().optional()
         }
@@ -1835,7 +1918,16 @@ var Api = {
             path: ModuleFilePath,
             patchId: PatchId,
             patch: zod.z.any() // TODO: this should be Patch instead - we got a weird validation error: although input looks good, it still does not accept objects as values... Which it should do via the z.record(JSONValue) type
-          }))
+          })),
+          // Patch group membership. Sent with the patch itself, in one request, so
+          // there is no window in which a patch exists but belongs to no group.
+          // Absent means "the caller does not know about groups" - the server then
+          // behaves exactly as before.
+          patchGroupId: zod.z.string().nullish(),
+          // What has to come with the patch: other patch ids that must join the
+          // same group for it to stay applicable. Computed on the client, which
+          // is the only side that has the schema needed to derive patch sets.
+          withPatchIds: zod.z.array(PatchId).optional()
         }),
         cookies: {
           val_session: zod.z.string().optional()
@@ -1861,7 +1953,8 @@ var Api = {
         status: zod.z.literal(200),
         json: zod.z.object({
           newPatchIds: zod.z.array(PatchId),
-          parentRef: ParentRef
+          parentRef: ParentRef,
+          patchGroupId: zod.z.string().optional()
         })
       })])
     },
@@ -1869,7 +1962,16 @@ var Api = {
       req: {
         query: {
           patch_id: zod.z.array(PatchId).optional(),
-          exclude_patch_ops: onlyOneBooleanQueryParam.optional()
+          exclude_patch_ops: onlyOneBooleanQueryParam.optional(),
+          /**
+           * Include the patch group annotation in the answer.
+           *
+           * Off by default because the client CHUNKS this request — a long
+           * chain is several round trips — and the groups are a property of the
+           * branch, identical in every chunk. Asking on each one is N identical
+           * lookups against the content API to learn the same thing.
+           */
+          include_patch_groups: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -1898,8 +2000,12 @@ var Api = {
             authorId: zod.z.string().nullable(),
             appliedAt: zod.z.object({
               commitSha: zod.z.string()
-            }).nullable()
+            }).nullable(),
+            // Which patch groups hold this patch. Optional so that FS mode, and
+            // any server that predates patch groups, can leave it out.
+            patchGroupIds: zod.z.array(zod.z.string()).optional()
           })),
+          patchGroups: zod.z.array(PatchGroup).optional(),
           baseSha: zod.z.string(),
           error: GenericError.optional(),
           errors: zod.z.record(PatchId, GenericError).optional()
@@ -1907,6 +2013,91 @@ var Api = {
       })])
     }
   },
+  // Patch group membership. Both are idempotent set operations, and both take an
+  // already-closed set: the client computes the prefix closure (staging) or the
+  // forward closure (unstaging) because only the client has the schema needed to
+  // derive patch sets. See `docs/independent-publish/PLAN.md`.
+  "/patch-groups/~/patches": {
+    PUT: {
+      req: {
+        body: zod.z.object({
+          patchGroupId: zod.z.string(),
+          /** What the user asked to stage. */
+          patchIds: zod.z.array(PatchId),
+          /*
+           * What has to come with it, because the staged patches are written on
+           * top of it.
+           *
+           * The content API records membership as `explicit` or `dependency`
+           * and reads what it is not told about as a dependency — so folding
+           * the two halves into `patchIds` files the patch someone clicked as
+           * something the closure dragged in.
+           */
+          withPatchIds: zod.z.array(PatchId).optional()
+        }).refine(function (body) {
+          var _body$withPatchIds$le, _body$withPatchIds;
+          return body.patchIds.length > 0 || ((_body$withPatchIds$le = (_body$withPatchIds = body.withPatchIds) === null || _body$withPatchIds === void 0 ? void 0 : _body$withPatchIds.length) !== null && _body$withPatchIds$le !== void 0 ? _body$withPatchIds$le : 0) > 0;
+        },
+        // Either half alone is a real request: a stage of only what came with
+        // it happens when the deferred queue's scope filter drops everything
+        // the user originally clicked.
+        "At least one patch id is required"),
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(403),
+        json: GenericError
+      }), zod.z.object({
+        // The group has already been published, so its membership is frozen.
+        status: zod.z.literal(409),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          patchGroupId: zod.z.string(),
+          patchIds: zod.z.array(PatchId)
+        })
+      })])
+    },
+    DELETE: {
+      req: {
+        body: zod.z.object({
+          patchGroupId: zod.z.string(),
+          /** What the user asked to unstage. */
+          patchIds: zod.z.array(PatchId),
+          /** What has to go with it: everything built on top of it. */
+          withPatchIds: zod.z.array(PatchId).optional()
+        }).refine(function (body) {
+          var _body$withPatchIds$le2, _body$withPatchIds2;
+          return body.patchIds.length > 0 || ((_body$withPatchIds$le2 = (_body$withPatchIds2 = body.withPatchIds) === null || _body$withPatchIds2 === void 0 ? void 0 : _body$withPatchIds2.length) !== null && _body$withPatchIds$le2 !== void 0 ? _body$withPatchIds$le2 : 0) > 0;
+        }, "At least one patch id is required"),
+        cookies: {
+          val_session: zod.z.string().optional()
+        }
+      },
+      res: zod.z.union([unauthorizedResponse, zod.z.object({
+        status: zod.z.literal(403),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(409),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(200),
+        json: zod.z.object({
+          patchGroupId: zod.z.string(),
+          patchIds: zod.z.array(PatchId)
+        })
+      })])
+    }
+  },
   "/schema": {
     GET: {
       req: {
@@ -1943,7 +2134,34 @@ var Api = {
           validate_sources: onlyOneBooleanQueryParam.optional(),
           validate_binary_files: onlyOneBooleanQueryParam.optional(),
           exclude_patches: onlyOneBooleanQueryParam.optional(),
-          apply_patches: onlyOneBooleanQueryParam.optional()
+          apply_patches: onlyOneBooleanQueryParam.optional(),
+          /**
+           * Apply ONLY these patches, rather than everything pending.
+           *
+           * This is what makes a draft-mode render match the caller's staged
+           * view. Without it `/sources/~` replays every pending patch on the
+           * branch, so a server-rendered preview shows other people's
+           * unpublished work — the one thing independent publish is for.
+           *
+           * Omitted means everything pending, which is the behaviour every
+           * existing caller has and must keep. An EMPTY array is a different
+           * answer and is honoured as one: a group holding nothing renders
+           * base.
+           */
+          patch_id: zod.z.array(PatchId).optional(),
+          /**
+           * Apply only the patches in the CALLER'S OWN patch groups.
+           *
+           * The server resolves them from the session, so a draft render does
+           * not have to know its own group ids — which it cannot, since it has
+           * no client state. This is what makes `fetchVal` in draft mode show
+           * the person their own staged work rather than everybody's.
+           *
+           * Ignored when `patch_id` is given: an explicit list is a caller that
+           * already knows what it wants, and silently intersecting the two
+           * would make the narrower one invisible.
+           */
+          own_patch_groups_only: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -2022,7 +2240,35 @@ var Api = {
       req: {
         body: zod.z.object({
           message: zod.z.string().optional(),
-          patchIds: zod.z.array(PatchId)
+          patchIds: zod.z.array(PatchId),
+          /*
+           * The patch group this commit EMPTIES, if it empties one.
+           *
+           * Forwarded to the content API, which closes the group it names —
+           * and closes it unconditionally, without checking that the commit
+           * shipped all of it. So the client sends it only when the publish
+           * accounts for every patch the group still holds; a partial publish
+           * omits it and the group stays open with the rest in it.
+           *
+           * Optional, and absent in `fs` mode, which has no groups.
+           */
+          patchGroupId: zod.z.string().optional(),
+          /*
+           * The newest commit this client knew about when it decided.
+           *
+           * Answered with 409 when the server sees a newer one, because then
+           * somebody else published between the review screen being read and
+           * Save being clicked, and what is about to ship was decided against a
+           * world that no longer exists.
+           *
+           * Git's own not-fast-forward guard does not cover this: `ValServer`
+           * fetches the chain and commits fresh at publish time, so the parent
+           * commit it sends is always the server's current one.
+           *
+           * Optional, so a client that does not track it publishes exactly as
+           * it did before.
+           */
+          expectedHeadCommitSha: zod.z.string().optional()
         }),
         cookies: {
           val_session: zod.z.string().optional()
@@ -2031,6 +2277,24 @@ var Api = {
       res: zod.z.union([unauthorizedResponse, zod.z.object({
         status: zod.z.literal(200),
         json: zod.z.object({
+          /**
+           * The commit this publish just made, which becomes the new publish
+           * head.
+           *
+           * Sent back because nothing else tells this client about its own
+           * commit in time. `headCommitSha` moves on a `/stat` response, and
+           * until the next poll lands the client still believes the
+           * PRE-publish head — so a second publish inside that window carried
+           * a stale `expectedHeadCommitSha`, the server compared it against
+           * the commit this same client had just made, and answered 409
+           * "someone else published". With auto-publish, which publishes on
+           * every pause in typing, that window is hit routinely and the
+           * message blames a colleague for the user's own commit.
+           *
+           * Optional: `fs` mode has no publish head, and neither does a
+           * server that predates this.
+           */
+          commitSha: zod.z.string().optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -2047,12 +2311,61 @@ var Api = {
             message: zod.z.string()
           })).optional()
         })
+      }),
+      /*
+       * The named patch group is not this caller's, or the lookup that would
+       * say so failed.
+       *
+       * Publishing may CLOSE a group, and closing somebody else's leaves
+       * their pending work in a closed group and in no open one. So `/save`
+       * runs the same ownership check stage and unstage do, and refuses the
+       * same way — see `refuseUnlessOwn`.
+       */
+      zod.z.object({
+        status: zod.z.literal(403),
+        json: GenericError
+      }), zod.z.object({
+        status: zod.z.literal(500),
+        json: GenericError
       }), zod.z.object({
         status: zod.z.literal(409),
-        json: zod.z.object({
+        json: zod.z.union([/** A group that has already shipped. See the 403 above. */
+        zod.z.object({
+          message: zod.z.string()
+        }), zod.z.object({
           message: zod.z.string(),
           isNotFastForward: zod.z.literal(true)
-        })
+        }),
+        /*
+         * Somebody else published between this being decided and Save.
+         *
+         * Its own shape rather than another `isNotFastForward`, because
+         * they happen at different moments and mean different things to the
+         * user: that one is git refusing a commit, this one is refused
+         * BEFORE a commit is attempted, on a head the client named. Nothing
+         * was written either way, but only this one is answered by looking
+         * at the review screen again.
+         */
+        zod.z.object({
+          message: zod.z.string(),
+          headMoved: zod.z.literal(true)
+        }),
+        /**
+         * The group this commit named has already been published.
+         *
+         * A third thing sharing 409, and flagged for the same reason
+         * `headMoved` is: read as a plain not-fast-forward it looks
+         * retryable, and it is the opposite — the id will never be writable
+         * again, so retrying reproduces it forever.
+         *
+         * It means this author published from somewhere else. The client
+         * forgets the id and falls back to the annotation, which is the
+         * same recovery a 409 on stage or unstage triggers.
+         */
+        zod.z.object({
+          message: zod.z.string(),
+          patchGroupPublished: zod.z.literal(true)
+        })])
       }), zod.z.object({
         status: zod.z.literal(400),
         json: zod.z.union([zod.z.object({
@@ -2133,7 +2446,16 @@ var Api = {
           limit: onlyOneIntQueryParam.refine(function (arg) {
             return arg > 0 && arg <= JSON_ENTRIES_BATCH_MAX;
           }, "limit must be between 1 and ".concat(JSON_ENTRIES_BATCH_MAX)).optional(),
-          apply_patches: onlyOneBooleanQueryParam.optional()
+          apply_patches: onlyOneBooleanQueryParam.optional(),
+          /**
+           * The caller's own staged work, and nobody else's.
+           *
+           * The same flag `/sources/~` takes, and for the same reason — a draft
+           * page renders both, so a scoped module beside an unscoped
+           * `jsonValues` entry showed one person's view and everybody's pending
+           * work on the same screen.
+           */
+          own_patch_groups_only: onlyOneBooleanQueryParam.optional()
         },
         cookies: _defineProperty({}, VAL_SESSION_COOKIE, zod.z.string().optional())
       },
@@ -2707,6 +3029,44 @@ var urlOf = function urlOf() {
   return "".concat(route);
 };
 
+/**
+ * The newest commit the client has been told about, or `null` if none.
+ *
+ * This is the **publish head**: unlike `baseSha`, which only moves once a
+ * deployment lands, it moves the instant somebody publishes. That makes it the
+ * one thing a client can carry to `/save` to say "this is the world I decided
+ * against" — and the only way the server can tell that somebody else has
+ * published since the review screen was read.
+ *
+ * In `shared` because both sides need the SAME answer: the client names a head
+ * and the server compares against one, so two implementations of "newest" is two
+ * ways to disagree about whether a publish is stale.
+ *
+ * By `createdAt` rather than by position, because the list's order is the
+ * content API's business and nothing here should depend on it. Ties keep the
+ * first seen, which is arbitrary and does not matter: two commits sharing a
+ * timestamp are equally "since", and either answer refuses the same publishes.
+ */
+function newestCommitSha(commits) {
+  var _newest$commitSha, _newest;
+  var newest = null;
+  var _iterator = _createForOfIteratorHelper(commits !== null && commits !== void 0 ? commits : []),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var commit = _step.value;
+      if (newest === null || commit.createdAt > newest.createdAt) {
+        newest = commit;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return (_newest$commitSha = (_newest = newest) === null || _newest === void 0 ? void 0 : _newest.commitSha) !== null && _newest$commitSha !== void 0 ? _newest$commitSha : null;
+}
+
 var VAL_CONFIG_SESSION_STORAGE_KEY = "val-config";
 var VAL_THEME_SESSION_STORAGE_KEY = "val-theme";
 var VAL_AI_SESSION_STORAGE_KEY = "val-ai-session";
@@ -2722,14 +3082,6 @@ var SharedValConfig = zod.z.object({
   ai: zod.z.object({
     commitMessages: zod.z.object({
       disabled: zod.z["boolean"]().optional()
-    }).optional(),
-    chat: zod.z.object({
-      experimental: zod.z.object({
-        enable: zod.z["boolean"]().optional()
-      }).optional(),
-      suggestions: zod.z.array(zod.z.string()).optional(),
-      title: zod.z.string().optional(),
-      description: zod.z.string().optional()
     }).optional()
   }).optional()
 });
@@ -3514,6 +3866,11 @@ function emptyOf(schema) {
     return [];
   } else if (schema.type === "record") {
     return {};
+  } else if (schema.type === "settings") {
+    // Not an object of empty sections: every settings key is optional, and
+    // absent IS the empty value. Filling the sections in would write a shape
+    // the project never asked for.
+    return {};
   } else if (schema.opt) {
     return null;
   } else if (schema.type === "richtext") {
@@ -4228,6 +4585,7 @@ exports.JSON_ENTRIES_BATCH_MAX = JSON_ENTRIES_BATCH_MAX;
 exports.ParentRef = ParentRef$1;
 exports.Patch = Patch;
 exports.PatchBlock = PatchBlock;
+exports.PatchGroup = PatchGroup;
 exports.PatchId = PatchId;
 exports.PatchJSON = PatchJSON;
 exports.RemirrorBr = RemirrorBr;
@@ -4296,6 +4654,7 @@ exports.isValCanvasFrame = isValCanvasFrame;
 exports.isValCanvasPageMessage = isValCanvasPageMessage;
 exports.isValCanvasStudioMessage = isValCanvasStudioMessage;
 exports.levenshtein = levenshtein;
+exports.newestCommitSha = newestCommitSha;
 exports.parseRoutePattern = parseRoutePattern;
 exports.partitionValidationErrors = partitionValidationErrors;
 exports.remirrorToRichTextSource = remirrorToRichTextSource;