@valbuild/shared 0.145.1 → 0.146.0

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

@@ -768,14 +768,16 @@ var VAL_ENABLE_COOKIE_NAME = core.Internal.VAL_ENABLE_COOKIE_NAME;
  * 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
+ * ## Why the scope is the REQUEST
  *
- * 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.
+ * The memoised response is a DRAFT -- unpublished work, read with the caller's
+ * session cookie. Every caller allowed to read drafts gets the same draft (patch
+ * groups, which made it per author, are gone), but whether a caller is allowed
+ * at all is decided per session. A memo that outlived the request would hand
+ * the draft to the next visitor without asking, and it would be invisible: the
+ * page would simply render somebody's half-finished sentence. Sharing it across
+ * requests is possible now, keyed on the chain's head, and would be its own
+ * measured change.
  *
  * 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
@@ -1733,21 +1735,6 @@ var StatProposal = zod.z.object({
   /** `val/p/<name>`. */
   branch: 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(),
@@ -2256,14 +2243,6 @@ var Api = {
            * highest version. Optional, for the same reason `headPatchId` is.
            */
           headVersion: zod.z.number().optional(),
-          /**
-           * Every group on the branch and which listed patches it holds,
-           * read with the list and `headVersion`. What a Studio's view of
-           * the groups is taken from, so a stage or an unstage made in
-           * another browser reaches it with the next stat. Absent where
-           * the content service has no groups.
-           */
-          patchGroups: zod.z.array(PatchGroup).optional(),
           commits: zod.z.array(ValCommit),
           /**
            * The publishes the content service knows about.
@@ -2560,24 +2539,6 @@ var Api = {
           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(),
           /*
            * Answer with `{ deleted, headVersion }` rather than the bare id
            * array. Asked for rather than always sent, because the array is
@@ -2619,16 +2580,7 @@ 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()
@@ -2670,7 +2622,6 @@ var Api = {
           error: PlanRefusalError,
           newPatchIds: zod.z.array(PatchId),
           parentRef: ParentRef,
-          patchGroupId: zod.z.string().optional(),
           headVersion: zod.z.number().optional()
         })
       }), zod.z.object({
@@ -2678,7 +2629,6 @@ var Api = {
         json: zod.z.object({
           newPatchIds: zod.z.array(PatchId),
           parentRef: ParentRef,
-          patchGroupId: zod.z.string().optional(),
           /**
            * The chain version the last of these patches made, comparable with
            * `headVersion` on `/stat`. A client keeps the highest version, so a
@@ -2693,16 +2643,7 @@ var Api = {
       req: {
         query: {
           patch_id: zod.z.array(PatchId).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()
+          exclude_patch_ops: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -2731,12 +2672,8 @@ var Api = {
             authorId: zod.z.string().nullable(),
             appliedAt: zod.z.object({
               commitSha: zod.z.string()
-            }).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()
+            }).nullable()
           })),
-          patchGroups: zod.z.array(PatchGroup).optional(),
           baseSha: zod.z.string(),
           error: GenericError.optional(),
           errors: zod.z.record(PatchId, GenericError).optional()
@@ -2744,111 +2681,6 @@ 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({
-          /**
-           * The group to stage into. Absent means the caller's open group on
-           * the branch, created if there is none — which is what the Studio
-           * sends, so a stage never has to wait for a group to exist.
-           */
-          patchGroupId: zod.z.string().optional(),
-          /** 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({
-          /** `null` for an unstage when the caller has no open group. */
-          patchGroupId: zod.z.string().nullable(),
-          patchIds: zod.z.array(PatchId),
-          /**
-           * The chain version the change committed at. The client keeps its
-           * own view of the change until a stat at least this new shows it.
-           * Absent from a content service that predates it.
-           */
-          headVersion: zod.z.number().optional()
-        })
-      })])
-    },
-    DELETE: {
-      req: {
-        body: zod.z.object({
-          /** See the PUT. Absent with no open group is a no-op. */
-          patchGroupId: zod.z.string().optional(),
-          /** 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({
-          /** `null` for an unstage when the caller has no open group. */
-          patchGroupId: zod.z.string().nullable(),
-          patchIds: zod.z.array(PatchId),
-          /**
-           * The chain version the change committed at. The client keeps its
-           * own view of the change until a stat at least this new shows it.
-           * Absent from a content service that predates it.
-           */
-          headVersion: zod.z.number().optional()
-        })
-      })])
-    }
-  },
   "/schema": {
     GET: {
       req: {
@@ -2885,34 +2717,7 @@ var Api = {
           validate_sources: onlyOneBooleanQueryParam.optional(),
           validate_binary_files: onlyOneBooleanQueryParam.optional(),
           exclude_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()
+          apply_patches: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -3072,18 +2877,6 @@ var Api = {
         body: zod.z.object({
           message: zod.z.string().optional(),
           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.
            *
@@ -3192,19 +2985,6 @@ var Api = {
            */
           headVersion: zod.z.number().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
@@ -3222,8 +3002,7 @@ var Api = {
         zod.z.object({
           message: zod.z.string(),
           publishRefusal: PublishRefusal
-        }), /** A group that has already shipped. See the 403 above. */
-        zod.z.object({
+        }), zod.z.object({
           message: zod.z.string()
         }), zod.z.object({
           message: zod.z.string(),
@@ -3242,22 +3021,6 @@ var Api = {
         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),
@@ -3552,16 +3315,7 @@ 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(),
-          /**
-           * 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()
+          apply_patches: onlyOneBooleanQueryParam.optional()
         },
         cookies: getSitemapTree._defineProperty({}, VAL_SESSION_COOKIE, zod.z.string().optional())
       },
@@ -4627,13 +4381,11 @@ function newestCommitSha(commits) {
  *
  * The head the server REPORTS (`headPatchId`) when it reports one, and not the
  * last patch it listed. The list — `/applicable/patches`, and `/stat` on top of
- * it — leaves out patches the running deployment already contains, and since
- * patch groups a publish can ship later patches while an earlier one stays
- * pending (another author's change that nets to nothing can never be published
- * at all). The last listed id is then behind the head for good, and the content
- * service accepts a write only on the head, so every save naming it is refused
- * — and a re-sync returns the same list. What fixed it in the Studio before
- * this existed was discarding the other author's change.
+ * it — leaves out patches the running deployment already contains, and a
+ * publish can ship later patches while an earlier one stays pending (a failed
+ * publish holds its changes back). The last listed id is then behind the head
+ * for good, and the content service accepts a write only on the head, so every
+ * save naming it is refused — and a re-sync returns the same list.
  *
  * `null` is a REPORTED empty chain, not "unknown". `undefined` is a server
  * that reports no head (`fs` mode, which ignores the parent anyway, or a
@@ -8088,6 +7840,517 @@ function parse(schema, body, call) {
   return parsed.data;
 }
 
+/**
+ * This functions returns all the possible schema types of a given module path.
+ */
+function schemaTypesOfPath(schema, patchPath) {
+  if (!patchPath || patchPath.length === 0) {
+    return new Set([schema.type]);
+  }
+  var branches = new Set();
+  var current = schema;
+  var i = -1;
+  var _iterator = getSitemapTree._createForOfIteratorHelper(patchPath),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var pathPart = _step.value;
+      i++;
+      if (!current) {
+        break;
+      }
+      if (current.type === "array") {
+        current = current.item;
+      } else if (current.type === "record") {
+        current = current.item;
+      } else if (current.type === "object" || current.type === "settings") {
+        current = current.items[pathPart];
+      } else if (current.type === "richtext") {
+        // richtext has internal structure (nodes with indices and tags), allow traversal
+        break;
+      } else if (current.type === "discriminated-union") {
+        var types = current.items;
+        var _iterator2 = getSitemapTree._createForOfIteratorHelper(types),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var type = _step2.value;
+            var subTypes = schemaTypesOfPath(type, patchPath.slice(i));
+            for (var _i = 0, _Array$from = Array.from(subTypes.values()); _i < _Array$from.length; _i++) {
+              var subType = _Array$from[_i];
+              branches.add(subType);
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return branches;
+      } else if (current.type === "enum" || current.type === "boolean" || current.type === "number" || current.type === "string" || current.type === "date" || current.type === "dateTime" || current.type === "color" || current.type === "code" || current.type === "file" || current.type === "image" || current.type === "video" || current.type === "keyOf" || current.type === "route" || current.type === "locale" || current.type === "literal" ||
+      // Nothing is patchable at a view path: the target module owns its source.
+      current.type === "view") {
+        if (current.type === "image" || current.type === "file") {
+          // allow changes to metadata
+          if (patchPath[i] === "metadata") {
+            break;
+          }
+        }
+        if (current.type === "video") {
+          // A video is edited a property at a time — its poster time, a caption
+          // track's label — so that two editors changing different parts of one
+          // video do not overwrite each other. Everything below it is the video.
+          break;
+        }
+        if (i !== patchPath.length - 1) {
+          throw new Error("Found " + current.type + " (primitive), but path has more parts: " + patchPath.join("/") + " at " + pathPart);
+        }
+        break;
+      } else {
+        var _unreachable = current;
+        var unknownType = _unreachable.type;
+        console.error("Unexecpted resolved schema type: ".concat(unknownType, " in ").concat(patchPath.join("/"), " at ").concat(pathPart));
+        return new Set([unknownType]);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (current) {
+    branches.add(current.type);
+    // A discriminated union's value IS an object, and an enum's IS a string:
+    // a patch op typed for either has to be accepted here too.
+    if (current.type === "discriminated-union") {
+      branches.add("object");
+    } else if (current.type === "enum") {
+      branches.add("string");
+    }
+  }
+  return branches;
+}
+
+// Examples: /file/name.val.ts?/path/to/patch
+
+/**
+ * A patch set is a set of patches that are non-independent of each other. This is useful for example when we want to apply a set of patches atomically.
+ * A patch set is identified by a module file path and a json patch path delimited by a '?' character. We call this the patch set path. Example: /file/name.val.ts?/path/to/patch
+ *
+ *
+ * NOTE: the order of patch sets is always newest first. This is because the UX always shows the newest patches first.
+ */
+
+/**
+ * Is `inner` strictly nested inside the patch set `outer`?
+ *
+ * A plain `inner.startsWith(outer)` is not enough, and the difference is not
+ * cosmetic. The file part of a key is terminated by the '?' delimiter, but the
+ * segments of the patch path are not terminated by anything, so a raw prefix
+ * test also matches siblings whose *name* merely starts with the same
+ * characters: '/p.val.ts?foobar/title' starts with '/p.val.ts?foo', so removing
+ * record key "foo" and retitling record key "foobar" would be merged into one
+ * patch set.
+ *
+ * That used to only over-group two unrelated changes in the compare view. Now
+ * that patch sets decide what moves between branches as one (whole patch sets,
+ * as `changesToMove` moves them), it means moving one key silently moves its
+ * similarly-named sibling — so the boundary has to be
+ * checked explicitly: '?' when `outer` is a bare module file path, '/' when it
+ * already has a patch path.
+ */
+function isInsidePatchSetPath(inner, outer) {
+  if (!inner.startsWith(outer)) {
+    return false;
+  }
+  var boundary = inner[outer.length];
+  return outer.includes("?") ? boundary === "/" : boundary === "?";
+}
+var PatchSets = /*#__PURE__*/function () {
+  function PatchSets() {
+    _classCallCheck(this, PatchSets);
+    getSitemapTree._defineProperty(this, "insertedPatches", void 0);
+    getSitemapTree._defineProperty(this, "patchSetMetadata", void 0);
+    getSitemapTree._defineProperty(this, "orderedInsertKeys", void 0);
+    this.patchSetMetadata = {};
+    this.orderedInsertKeys = [];
+    this.insertedPatches = new Set();
+  }
+  return _createClass(PatchSets, [{
+    key: "reset",
+    value: function reset() {
+      this.patchSetMetadata = {};
+      this.orderedInsertKeys = [];
+      this.insertedPatches = new Set();
+    }
+  }, {
+    key: "getInsertedPatches",
+    value: function getInsertedPatches() {
+      return this.insertedPatches;
+    }
+  }, {
+    key: "insertPath",
+    value: function insertPath(moduleFilePath, affectsPatchPath, patchId, createdAt, author, opType, schemaTypes, opPath) {
+      var newPatchSetPath = affectsPatchPath.length > 0 ? "".concat(moduleFilePath, "?").concat(affectsPatchPath.join("/")) : moduleFilePath;
+      var pathIndexesThatMustBeMerged = [];
+      // TODO: current implementation is O(n), with isInside it is: O(n x m) - there's room for optimization (Trie?). Just make sure order is maintained and that insert AND then serialize is what we optimize for because the UX will do an insert, then serialize immediately after
+      for (var i = this.orderedInsertKeys.length - 1; i >= 0; i--) {
+        var currentInsertKey = this.orderedInsertKeys[i];
+        if (newPatchSetPath !== currentInsertKey) {
+          if (isInsidePatchSetPath(newPatchSetPath, currentInsertKey)) {
+            // This new patch set is inside an existing patch set...
+            // Use the existing patch set as the new name
+            newPatchSetPath = currentInsertKey;
+            // Move to new patch set to head
+            this.orderedInsertKeys.splice(i, 1);
+            this.orderedInsertKeys.unshift(newPatchSetPath);
+          } else if (isInsidePatchSetPath(currentInsertKey, newPatchSetPath)) {
+            // We found a patch set (with a shorter path) that needs to be merged into this new patch set
+            pathIndexesThatMustBeMerged.push(i);
+          }
+        } else {
+          // This patch set already exists
+          // Move to new patch set to head
+          this.orderedInsertKeys.splice(i, 1);
+          this.orderedInsertKeys.unshift(newPatchSetPath);
+        }
+      }
+
+      // Merge existing patch sets into this new one:
+      for (var _i = 0, _pathIndexesThatMustB = pathIndexesThatMustBeMerged; _i < _pathIndexesThatMustB.length; _i++) {
+        var pathIndexThatMustBeMerged = _pathIndexesThatMustB[_i];
+        var moduleFileOrPatchSetPath = this.orderedInsertKeys[pathIndexThatMustBeMerged];
+
+        // 1) remove the old patch set path from ordered insert key
+        this.orderedInsertKeys.splice(pathIndexThatMustBeMerged, 1);
+
+        // 2) merge metadata into new
+        var existingPatchSetMetadata = this.patchSetMetadata[moduleFileOrPatchSetPath];
+        if (!this.patchSetMetadata[newPatchSetPath]) {
+          this.patchSetMetadata[newPatchSetPath] = {
+            moduleFilePath: moduleFilePath,
+            patchPath: affectsPatchPath,
+            patches: [],
+            authors: [],
+            opTypes: [],
+            schemaTypes: Array.from(schemaTypes),
+            lastUpdated: createdAt,
+            lastUpdatedBy: author
+          };
+        }
+        if (existingPatchSetMetadata) {
+          var _iterator = getSitemapTree._createForOfIteratorHelper(existingPatchSetMetadata.patches.slice()),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var patchMetadata = _step.value;
+              this.patchSetMetadata[newPatchSetPath].patches.unshift(patchMetadata);
+              if (patchMetadata.author !== null) {
+                this.patchSetMetadata[newPatchSetPath].authors.unshift(patchMetadata.author);
+              }
+              this.patchSetMetadata[newPatchSetPath].opTypes.unshift(patchMetadata.opType);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        } else {
+          throw new Error("Could not find patch set metadata or patch metadata for (inserted) patch set path: ".concat(moduleFileOrPatchSetPath));
+        }
+
+        // 3) delete old metadata
+        if (moduleFileOrPatchSetPath !== newPatchSetPath) {
+          delete this.patchSetMetadata[moduleFileOrPatchSetPath];
+        }
+      }
+
+      // Insert new metadata
+      if (!this.patchSetMetadata[newPatchSetPath]) {
+        this.patchSetMetadata[newPatchSetPath] = {
+          moduleFilePath: moduleFilePath,
+          patchPath: affectsPatchPath,
+          patches: [],
+          authors: [],
+          opTypes: [],
+          schemaTypes: schemaTypes,
+          lastUpdated: createdAt,
+          lastUpdatedBy: author
+        };
+      }
+      if (author !== null && !this.patchSetMetadata[newPatchSetPath].authors.includes(author)) {
+        this.patchSetMetadata[newPatchSetPath].authors.unshift(author);
+      }
+      this.patchSetMetadata[newPatchSetPath].lastUpdatedBy = author;
+      this.patchSetMetadata[newPatchSetPath].lastUpdated = createdAt;
+      if (!this.patchSetMetadata[newPatchSetPath].opTypes.includes(opType)) {
+        this.patchSetMetadata[newPatchSetPath].opTypes.unshift(opType);
+      }
+      this.patchSetMetadata[newPatchSetPath].patches.unshift({
+        patchPath: opPath,
+        patchId: patchId,
+        author: author,
+        createdAt: createdAt,
+        opType: opType,
+        schemaTypes: schemaTypes
+      });
+      if (!this.orderedInsertKeys.includes(newPatchSetPath)) {
+        this.orderedInsertKeys.unshift(newPatchSetPath);
+      }
+    }
+
+    /**
+     * Insert a whole patch.
+     *
+     * Takes the patch rather than one op because the de-duplication below is
+     * per-*patch*: a patch is either known to this instance or it is not. When this
+     * took a single op, callers looped and every call after the first hit the
+     * `insertedPatches` guard and returned — so only a patch's first op ever reached
+     * a patch set. A patch that touched two places (a `move`, or a `file` op sitting
+     * before its source op) was therefore mis-grouped, which is invisible in the
+     * compare view but decides what moves as one.
+     */
+  }, {
+    key: "insert",
+    value: function insert(moduleFilePath, schema, patch, patchId, createdAt, author) {
+      if (this.insertedPatches.has(patchId)) {
+        return;
+      }
+      // Marked inserted unconditionally, schema or not. An earlier revision of this
+      // fix only marked it once a schema was available, so that a patch grouped
+      // under the whole-module fallback could be re-inserted later with the real
+      // schema. That is no longer this class's problem: `PatchSetChain` invalidates
+      // on `schema:init` and a rebuild calls `reset()`, which clears this set — so
+      // the fallback is already re-derived from scratch when the schema lands, and a
+      // conditional here would only leave the per-patch de-duplication half-applied.
+      this.insertedPatches.add(patchId);
+      var _iterator2 = getSitemapTree._createForOfIteratorHelper(patch),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var op = _step2.value;
+          this.insertOp(moduleFilePath, schema, op, patchId, createdAt, author);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "insertOp",
+    value: function insertOp(moduleFilePath, schema, op, patchId, createdAt, author) {
+      if (!schema) {
+        this.insertPath(moduleFilePath, [], patchId, createdAt, author, op.op, [], op.path);
+        return;
+      }
+      if (op.op === "file" || op.op === "test") {
+        return;
+      }
+      try {
+        if (op.op === "replace") {
+          var schemaTypesAtPath = schemaTypesOfPath(schema, op.path);
+          this.insertPath(moduleFilePath, op.path, patchId, createdAt, author, op.op, Array.from(schemaTypesAtPath), op.path);
+        } else if (op.op === "add" || op.op === "remove" || op.op === "move" || op.op === "copy") {
+          // This is the default case, were we, to be sure, take the parent of the path and as the patch set
+          var path = op.path.slice(0, -1);
+          var _schemaTypesAtPath = schemaTypesOfPath(schema, path);
+          if (_schemaTypesAtPath.size === 1 && _schemaTypesAtPath.has("array")) {
+            // for arrays we would need a lot of logic to create a patch set that is not on the entire parent so for now we do just that
+            this.insertPath(moduleFilePath, path, patchId, createdAt, author, op.op, Array.from(_schemaTypesAtPath), op.path);
+            if (op.op === "move" || op.op === "copy") {
+              // `copy` as well as `move`: it does not write the source, but it
+              // READS it, so the value it produces depends on every pending edit
+              // to that source and on the indices around it.
+              var _path = op.from.slice(0, -1);
+              var _schemaTypesAtPath2 = schemaTypesOfPath(schema, _path);
+              this.insertPath(moduleFilePath, _path, patchId, createdAt, author, op.op, Array.from(_schemaTypesAtPath2), op.path);
+            }
+          } else if (_schemaTypesAtPath.size === 1 && (_schemaTypesAtPath.has("record") ||
+          // An OBJECT is keyed too: its keys are named rather than
+          // positional, so neither `add` (create-or-set, `addToNode` in
+          // `@valbuild/core/patch`) nor `remove` (delete the property)
+          // disturbs any sibling. Either way the op affects exactly the key
+          // it names and nothing else, which is the property this branch
+          // needs — unlike an array, where both shift every later index.
+          //
+          // The studio emits `add` rather than `replace` here on purpose, so
+          // that the write survives the key having gone away in the meantime:
+          // see `ImageField`'s alt write and
+          // `ModuleGallery.handleAltTextChange`, which both say so.
+          //
+          // That last one is why this branch exists. `s.imagedir()`
+          // serializes as a record whose ITEM is an object, so editing the
+          // alt text of a gallery entry resolves `object` here, hit the throw
+          // below, and terminated the whole media module into one patch set —
+          // once per keystroke. Moving any one change in that module then
+          // dragged every other change in it along, because changes move a
+          // whole patch set at a time.
+          _schemaTypesAtPath.has("object") ||
+          // A settings SECTION is addressed like a record: its keys are
+          // named, and an `add` at ["theme", "accent"] modifies exactly that
+          // one. Without this it fell to the throw below — every settings
+          // edit terminated the whole module into one patch set, which is why
+          // the publish diff said "Settings" where `settingsChangeLabels` has
+          // a name for the field. Both sections write `add` this way; see
+          // `useWriteAssistantSetting`, which has to create an absent section
+          // in a single op.
+          _schemaTypesAtPath.has("settings"))) {
+            // If we know this is a record, we can be more specific and only insert the path that is being modified
+            var _path2 = op.path;
+            var _schemaTypesAtPath3 = schemaTypesOfPath(schema, _path2);
+            this.insertPath(moduleFilePath, _path2, patchId, createdAt, author, op.op, Array.from(_schemaTypesAtPath3), op.path);
+            if (op.op === "move" || op.op === "copy") {
+              // The SOURCE is classified on its own terms, not the
+              // destination's. A move out of an array item shifts every later
+              // index, so that side has to be the array — exactly as the branch
+              // above does for a move whose destination is an array. Only when
+              // the source parent is keyed too does `op.from` name the whole of
+              // what the op affects.
+              //
+              // `copy` reaches here as well as `move`. It does not write the
+              // source, but the value it produces is read from it, so it depends
+              // on every pending edit to that source just as a move does.
+              // Duplicating a record entry (`useDuplicateRecordEntry`) is
+              // the copy that actually ships, and its source went ungrouped.
+              var fromParent = op.from.slice(0, -1);
+              var fromParentTypes = schemaTypesOfPath(schema, fromParent);
+              // ANY possible array parent widens, rather than only an
+              // unambiguous one: a discriminated union resolves to every
+              // variant's type at once, so a source inside one can be an array
+              // here and an object there. Requiring a single type grouped it at
+              // the item, which is wrong the moment the array variant is the
+              // live one — and the whole array is the safe direction.
+              var isPositionalSource = fromParentTypes.has("array");
+              var _path3 = isPositionalSource ? fromParent : op.from;
+              var _schemaTypesAtPath4 = schemaTypesOfPath(schema, _path3);
+              this.insertPath(moduleFilePath, _path3, patchId, createdAt, author, op.op, Array.from(_schemaTypesAtPath4), op.path);
+            }
+          } else if (_schemaTypesAtPath.size === 1 && !(_schemaTypesAtPath.has("image") || _schemaTypesAtPath.has("file"))) {
+            // What is left is a parent this function cannot isolate a key
+            // inside. Two different reasons end up here, and the message covers
+            // both: a PRIMITIVE cannot hold the key at all, which means the path
+            // no longer fits the schema — a genuinely stale patch; and `richtext`
+            // can, but its children are positional, so isolating one would let a
+            // node insert be moved without the edits whose indices it shifted.
+            // Both keep reporting, and the catch below terminates the module,
+            // which is the conservative thing to do when we cannot say what a
+            // change affects.
+            throw new Error("Cannot isolate a patch set for op: '".concat(op.op, "' \u2014 no addressable key inside schema type: ").concat(_schemaTypesAtPath.values().next().value));
+          } else {
+            // we cannot really know if this is a record or array so the entire module is the patch set
+            this.insertPath(moduleFilePath, path, patchId, createdAt, author, op.op, [schema.type], op.path);
+          }
+        } else {
+          var _unreachable = op;
+          throw new Error("Unreachable op: " + _unreachable);
+        }
+      } catch (e) {
+        // We might be in this situation if the schema changes, etc etc:
+        if (e instanceof Error) {
+          console.error("Could not resolve path while creating patch set", e.message);
+        } else {
+          console.error("Could not resolve path while creating patch set", e);
+        }
+        // "terminate" the entire module file path (i.e. all patches are their own patch set)
+        this.insertPath(moduleFilePath, [], patchId, createdAt, author, op.op, [schema.type], op.path);
+      }
+    }
+  }, {
+    key: "isInserted",
+    value: function isInserted(patchId) {
+      return this.insertedPatches.has(patchId);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      var _this = this;
+      return this.orderedInsertKeys.map(function (key) {
+        if (key in _this.patchSetMetadata) {
+          return _this.patchSetMetadata[key];
+        } else {
+          throw new Error("Could not find patch set metadata or patch metadata for (inserted) patch set path: ".concat(key));
+        }
+      });
+    }
+  }]);
+}();
+
+/**
+ * Update from the site, for a proposal with code (valbuild/home
+ * `docs/hosted-publishing.md` step 8.2, slice 1b): what content hands over,
+ * what the builder tab makes of it, and what Val's server reads -- one
+ * definition of each for the three.
+ */
+
+/** Content a schema does not allow, by path in the module. */
+
+/** Content's `merge-trees` answer. */
+
+/** Which tree: where the proposal started, the site, or the proposal. */
+
+/** A module, as evaluating its tree in the tab gave it. */
+
+/** A side's files: the site's tree, the base's changes over it, the proposal's over that. */
+function sideFiles(trees, side) {
+  var layers = side === "site" ? [] : side === "base" ? [trees.trees.base] : [trees.trees.base, trees.trees.proposal];
+  var files = getSitemapTree._objectSpread2({}, trees.trees.site);
+  for (var _i = 0, _layers = layers; _i < _layers.length; _i++) {
+    var layer = _layers[_i];
+    for (var _i2 = 0, _Object$entries = Object.entries(layer); _i2 < _Object$entries.length; _i2++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+        path = _Object$entries$_i[0],
+        text = _Object$entries$_i[1];
+      if (text === null) delete files[path];else files[path] = text;
+    }
+  }
+  return files;
+}
+
+/** A side's Source of a module, from content's index; `null` when it has none. */
+function sideSource(trees, side, moduleFilePath) {
+  var _trees$modules$module, _trees$modules$module2, _trees$sources$sha;
+  var sha = (_trees$modules$module = (_trees$modules$module2 = trees.modules[moduleFilePath]) === null || _trees$modules$module2 === void 0 ? void 0 : _trees$modules$module2[side]) !== null && _trees$modules$module !== void 0 ? _trees$modules$module : null;
+  return sha === null ? null : (_trees$sources$sha = trees.sources[sha]) !== null && _trees$sources$sha !== void 0 ? _trees$sources$sha : null;
+}
+
+/**
+ * What a schema reports about this content, without the errors the server
+ * fixes on its own (those with `fixes`): run on the schema instance that
+ * evaluating the module made, so custom rules take part.
+ */
+function schemaErrorsOf(schema, moduleFilePath, source) {
+  var res = schema["executeValidate"](moduleFilePath, source);
+  if (res === false) return [];
+  var errors = [];
+  for (var _i3 = 0, _Object$entries2 = Object.entries(res); _i3 < _Object$entries2.length; _i3++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i3], 2),
+      sourcePath = _Object$entries2$_i[0],
+      list = _Object$entries2$_i[1];
+    var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(sourcePath),
+      _Internal$splitModule2 = _slicedToArray(_Internal$splitModule, 2),
+      modulePath = _Internal$splitModule2[1];
+    var path = modulePath ? core.Internal.createPatchPath(modulePath) : [];
+    var _iterator = getSitemapTree._createForOfIteratorHelper(list),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var error = _step.value;
+        if (error.fixes && error.fixes.length > 0) continue;
+        errors.push({
+          path: path,
+          message: error.message
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return errors;
+}
+
 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;
@@ -8131,9 +8394,9 @@ exports.NEVER_ENCODED = NEVER_ENCODED;
 exports.ParentRef = ParentRef$1;
 exports.Patch = Patch;
 exports.PatchBlock = PatchBlock;
-exports.PatchGroup = PatchGroup;
 exports.PatchId = PatchId;
 exports.PatchJSON = PatchJSON;
+exports.PatchSets = PatchSets;
 exports.PlanRefusalError = PlanRefusalError;
 exports.PublishProtocolError = PublishProtocolError;
 exports.RAMP_STEPS = RAMP_STEPS;
@@ -8218,6 +8481,7 @@ exports.getRoutesOf = getRoutesOf;
 exports.getRoutesWithModulePaths = getRoutesWithModulePaths;
 exports.getSourceAt = getSourceAt;
 exports.indexModule = indexModule;
+exports.isInsidePatchSetPath = isInsidePatchSetPath;
 exports.isMimeTypeAccepted = isMimeTypeAccepted;
 exports.isRemoteSchema = isRemoteSchema;
 exports.isSchemaSourceFixError = isSchemaSourceFixError;
@@ -8257,6 +8521,10 @@ exports.resolveSerializedSchemaAtPath = resolveSerializedSchemaAtPath;
 exports.richTextImageSchema = richTextImageSchema;
 exports.richTextToRemirror = richTextToRemirror;
 exports.safeParsePatch = safeParsePatch;
+exports.schemaErrorsOf = schemaErrorsOf;
+exports.schemaTypesOfPath = schemaTypesOfPath;
+exports.sideFiles = sideFiles;
+exports.sideSource = sideSource;
 exports.sourcePathOfChild = sourcePathOfChild;
 exports.themeCustomProperties = themeCustomProperties;
 exports.toolNames = toolNames;