@pstdio/sdk 0.44.0 → 0.45.0-nightly.20261020145025

package/dist/testing/index.js

@@ -1,4 +1,36 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -13,6 +45,730 @@ var __export = (target, all) => {
     });
 };
 
+// ../../node_modules/.bun/fast-diff@1.3.0/node_modules/fast-diff/diff.js
+var require_diff = __commonJS(function(exports, module) {
+  var DIFF_DELETE = -1;
+  var DIFF_INSERT = 1;
+  var DIFF_EQUAL = 0;
+  function diff_main(text1, text2, cursor_pos, cleanup, _fix_unicode) {
+    if (text1 === text2) {
+      if (text1) {
+        return [[DIFF_EQUAL, text1]];
+      }
+      return [];
+    }
+    if (cursor_pos != null) {
+      var editdiff = find_cursor_edit_diff(text1, text2, cursor_pos);
+      if (editdiff) {
+        return editdiff;
+      }
+    }
+    var commonlength = diff_commonPrefix(text1, text2);
+    var commonprefix = text1.substring(0, commonlength);
+    text1 = text1.substring(commonlength);
+    text2 = text2.substring(commonlength);
+    commonlength = diff_commonSuffix(text1, text2);
+    var commonsuffix = text1.substring(text1.length - commonlength);
+    text1 = text1.substring(0, text1.length - commonlength);
+    text2 = text2.substring(0, text2.length - commonlength);
+    var diffs = diff_compute_(text1, text2);
+    if (commonprefix) {
+      diffs.unshift([DIFF_EQUAL, commonprefix]);
+    }
+    if (commonsuffix) {
+      diffs.push([DIFF_EQUAL, commonsuffix]);
+    }
+    diff_cleanupMerge(diffs, _fix_unicode);
+    if (cleanup) {
+      diff_cleanupSemantic(diffs);
+    }
+    return diffs;
+  }
+  function diff_compute_(text1, text2) {
+    var diffs;
+    if (!text1) {
+      return [[DIFF_INSERT, text2]];
+    }
+    if (!text2) {
+      return [[DIFF_DELETE, text1]];
+    }
+    var longtext = text1.length > text2.length ? text1 : text2;
+    var shorttext = text1.length > text2.length ? text2 : text1;
+    var i = longtext.indexOf(shorttext);
+    if (i !== -1) {
+      diffs = [
+        [DIFF_INSERT, longtext.substring(0, i)],
+        [DIFF_EQUAL, shorttext],
+        [DIFF_INSERT, longtext.substring(i + shorttext.length)]
+      ];
+      if (text1.length > text2.length) {
+        diffs[0][0] = diffs[2][0] = DIFF_DELETE;
+      }
+      return diffs;
+    }
+    if (shorttext.length === 1) {
+      return [
+        [DIFF_DELETE, text1],
+        [DIFF_INSERT, text2]
+      ];
+    }
+    var hm = diff_halfMatch_(text1, text2);
+    if (hm) {
+      var text1_a = hm[0];
+      var text1_b = hm[1];
+      var text2_a = hm[2];
+      var text2_b = hm[3];
+      var mid_common = hm[4];
+      var diffs_a = diff_main(text1_a, text2_a);
+      var diffs_b = diff_main(text1_b, text2_b);
+      return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
+    }
+    return diff_bisect_(text1, text2);
+  }
+  function diff_bisect_(text1, text2) {
+    var text1_length = text1.length;
+    var text2_length = text2.length;
+    var max_d = Math.ceil((text1_length + text2_length) / 2);
+    var v_offset = max_d;
+    var v_length = 2 * max_d;
+    var v1 = new Array(v_length);
+    var v2 = new Array(v_length);
+    for (var x = 0;x < v_length; x++) {
+      v1[x] = -1;
+      v2[x] = -1;
+    }
+    v1[v_offset + 1] = 0;
+    v2[v_offset + 1] = 0;
+    var delta = text1_length - text2_length;
+    var front = delta % 2 !== 0;
+    var k1start = 0;
+    var k1end = 0;
+    var k2start = 0;
+    var k2end = 0;
+    for (var d = 0;d < max_d; d++) {
+      for (var k1 = -d + k1start;k1 <= d - k1end; k1 += 2) {
+        var k1_offset = v_offset + k1;
+        var x1;
+        if (k1 === -d || k1 !== d && v1[k1_offset - 1] < v1[k1_offset + 1]) {
+          x1 = v1[k1_offset + 1];
+        } else {
+          x1 = v1[k1_offset - 1] + 1;
+        }
+        var y1 = x1 - k1;
+        while (x1 < text1_length && y1 < text2_length && text1.charAt(x1) === text2.charAt(y1)) {
+          x1++;
+          y1++;
+        }
+        v1[k1_offset] = x1;
+        if (x1 > text1_length) {
+          k1end += 2;
+        } else if (y1 > text2_length) {
+          k1start += 2;
+        } else if (front) {
+          var k2_offset = v_offset + delta - k1;
+          if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {
+            var x2 = text1_length - v2[k2_offset];
+            if (x1 >= x2) {
+              return diff_bisectSplit_(text1, text2, x1, y1);
+            }
+          }
+        }
+      }
+      for (var k2 = -d + k2start;k2 <= d - k2end; k2 += 2) {
+        var k2_offset = v_offset + k2;
+        var x2;
+        if (k2 === -d || k2 !== d && v2[k2_offset - 1] < v2[k2_offset + 1]) {
+          x2 = v2[k2_offset + 1];
+        } else {
+          x2 = v2[k2_offset - 1] + 1;
+        }
+        var y2 = x2 - k2;
+        while (x2 < text1_length && y2 < text2_length && text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)) {
+          x2++;
+          y2++;
+        }
+        v2[k2_offset] = x2;
+        if (x2 > text1_length) {
+          k2end += 2;
+        } else if (y2 > text2_length) {
+          k2start += 2;
+        } else if (!front) {
+          var k1_offset = v_offset + delta - k2;
+          if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] !== -1) {
+            var x1 = v1[k1_offset];
+            var y1 = v_offset + x1 - k1_offset;
+            x2 = text1_length - x2;
+            if (x1 >= x2) {
+              return diff_bisectSplit_(text1, text2, x1, y1);
+            }
+          }
+        }
+      }
+    }
+    return [
+      [DIFF_DELETE, text1],
+      [DIFF_INSERT, text2]
+    ];
+  }
+  function diff_bisectSplit_(text1, text2, x, y) {
+    var text1a = text1.substring(0, x);
+    var text2a = text2.substring(0, y);
+    var text1b = text1.substring(x);
+    var text2b = text2.substring(y);
+    var diffs = diff_main(text1a, text2a);
+    var diffsb = diff_main(text1b, text2b);
+    return diffs.concat(diffsb);
+  }
+  function diff_commonPrefix(text1, text2) {
+    if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {
+      return 0;
+    }
+    var pointermin = 0;
+    var pointermax = Math.min(text1.length, text2.length);
+    var pointermid = pointermax;
+    var pointerstart = 0;
+    while (pointermin < pointermid) {
+      if (text1.substring(pointerstart, pointermid) == text2.substring(pointerstart, pointermid)) {
+        pointermin = pointermid;
+        pointerstart = pointermin;
+      } else {
+        pointermax = pointermid;
+      }
+      pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+    }
+    if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {
+      pointermid--;
+    }
+    return pointermid;
+  }
+  function diff_commonOverlap_(text1, text2) {
+    var text1_length = text1.length;
+    var text2_length = text2.length;
+    if (text1_length == 0 || text2_length == 0) {
+      return 0;
+    }
+    if (text1_length > text2_length) {
+      text1 = text1.substring(text1_length - text2_length);
+    } else if (text1_length < text2_length) {
+      text2 = text2.substring(0, text1_length);
+    }
+    var text_length = Math.min(text1_length, text2_length);
+    if (text1 == text2) {
+      return text_length;
+    }
+    var best = 0;
+    var length = 1;
+    while (true) {
+      var pattern = text1.substring(text_length - length);
+      var found = text2.indexOf(pattern);
+      if (found == -1) {
+        return best;
+      }
+      length += found;
+      if (found == 0 || text1.substring(text_length - length) == text2.substring(0, length)) {
+        best = length;
+        length++;
+      }
+    }
+  }
+  function diff_commonSuffix(text1, text2) {
+    if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {
+      return 0;
+    }
+    var pointermin = 0;
+    var pointermax = Math.min(text1.length, text2.length);
+    var pointermid = pointermax;
+    var pointerend = 0;
+    while (pointermin < pointermid) {
+      if (text1.substring(text1.length - pointermid, text1.length - pointerend) == text2.substring(text2.length - pointermid, text2.length - pointerend)) {
+        pointermin = pointermid;
+        pointerend = pointermin;
+      } else {
+        pointermax = pointermid;
+      }
+      pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+    }
+    if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {
+      pointermid--;
+    }
+    return pointermid;
+  }
+  function diff_halfMatch_(text1, text2) {
+    var longtext = text1.length > text2.length ? text1 : text2;
+    var shorttext = text1.length > text2.length ? text2 : text1;
+    if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
+      return null;
+    }
+    function diff_halfMatchI_(longtext, shorttext, i) {
+      var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
+      var j = -1;
+      var best_common = "";
+      var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
+      while ((j = shorttext.indexOf(seed, j + 1)) !== -1) {
+        var prefixLength = diff_commonPrefix(longtext.substring(i), shorttext.substring(j));
+        var suffixLength = diff_commonSuffix(longtext.substring(0, i), shorttext.substring(0, j));
+        if (best_common.length < suffixLength + prefixLength) {
+          best_common = shorttext.substring(j - suffixLength, j) + shorttext.substring(j, j + prefixLength);
+          best_longtext_a = longtext.substring(0, i - suffixLength);
+          best_longtext_b = longtext.substring(i + prefixLength);
+          best_shorttext_a = shorttext.substring(0, j - suffixLength);
+          best_shorttext_b = shorttext.substring(j + prefixLength);
+        }
+      }
+      if (best_common.length * 2 >= longtext.length) {
+        return [
+          best_longtext_a,
+          best_longtext_b,
+          best_shorttext_a,
+          best_shorttext_b,
+          best_common
+        ];
+      } else {
+        return null;
+      }
+    }
+    var hm1 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4));
+    var hm2 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2));
+    var hm;
+    if (!hm1 && !hm2) {
+      return null;
+    } else if (!hm2) {
+      hm = hm1;
+    } else if (!hm1) {
+      hm = hm2;
+    } else {
+      hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
+    }
+    var text1_a, text1_b, text2_a, text2_b;
+    if (text1.length > text2.length) {
+      text1_a = hm[0];
+      text1_b = hm[1];
+      text2_a = hm[2];
+      text2_b = hm[3];
+    } else {
+      text2_a = hm[0];
+      text2_b = hm[1];
+      text1_a = hm[2];
+      text1_b = hm[3];
+    }
+    var mid_common = hm[4];
+    return [text1_a, text1_b, text2_a, text2_b, mid_common];
+  }
+  function diff_cleanupSemantic(diffs) {
+    var changes = false;
+    var equalities = [];
+    var equalitiesLength = 0;
+    var lastequality = null;
+    var pointer = 0;
+    var length_insertions1 = 0;
+    var length_deletions1 = 0;
+    var length_insertions2 = 0;
+    var length_deletions2 = 0;
+    while (pointer < diffs.length) {
+      if (diffs[pointer][0] == DIFF_EQUAL) {
+        equalities[equalitiesLength++] = pointer;
+        length_insertions1 = length_insertions2;
+        length_deletions1 = length_deletions2;
+        length_insertions2 = 0;
+        length_deletions2 = 0;
+        lastequality = diffs[pointer][1];
+      } else {
+        if (diffs[pointer][0] == DIFF_INSERT) {
+          length_insertions2 += diffs[pointer][1].length;
+        } else {
+          length_deletions2 += diffs[pointer][1].length;
+        }
+        if (lastequality && lastequality.length <= Math.max(length_insertions1, length_deletions1) && lastequality.length <= Math.max(length_insertions2, length_deletions2)) {
+          diffs.splice(equalities[equalitiesLength - 1], 0, [
+            DIFF_DELETE,
+            lastequality
+          ]);
+          diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+          equalitiesLength--;
+          equalitiesLength--;
+          pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+          length_insertions1 = 0;
+          length_deletions1 = 0;
+          length_insertions2 = 0;
+          length_deletions2 = 0;
+          lastequality = null;
+          changes = true;
+        }
+      }
+      pointer++;
+    }
+    if (changes) {
+      diff_cleanupMerge(diffs);
+    }
+    diff_cleanupSemanticLossless(diffs);
+    pointer = 1;
+    while (pointer < diffs.length) {
+      if (diffs[pointer - 1][0] == DIFF_DELETE && diffs[pointer][0] == DIFF_INSERT) {
+        var deletion = diffs[pointer - 1][1];
+        var insertion = diffs[pointer][1];
+        var overlap_length1 = diff_commonOverlap_(deletion, insertion);
+        var overlap_length2 = diff_commonOverlap_(insertion, deletion);
+        if (overlap_length1 >= overlap_length2) {
+          if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
+            diffs.splice(pointer, 0, [
+              DIFF_EQUAL,
+              insertion.substring(0, overlap_length1)
+            ]);
+            diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
+            diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+            pointer++;
+          }
+        } else {
+          if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
+            diffs.splice(pointer, 0, [
+              DIFF_EQUAL,
+              deletion.substring(0, overlap_length2)
+            ]);
+            diffs[pointer - 1][0] = DIFF_INSERT;
+            diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+            diffs[pointer + 1][0] = DIFF_DELETE;
+            diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+            pointer++;
+          }
+        }
+        pointer++;
+      }
+      pointer++;
+    }
+  }
+  var nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+  var whitespaceRegex_ = /\s/;
+  var linebreakRegex_ = /[\r\n]/;
+  var blanklineEndRegex_ = /\n\r?\n$/;
+  var blanklineStartRegex_ = /^\r?\n\r?\n/;
+  function diff_cleanupSemanticLossless(diffs) {
+    function diff_cleanupSemanticScore_(one, two) {
+      if (!one || !two) {
+        return 6;
+      }
+      var char1 = one.charAt(one.length - 1);
+      var char2 = two.charAt(0);
+      var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
+      var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
+      var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
+      var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
+      var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
+      var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
+      var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
+      var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
+      if (blankLine1 || blankLine2) {
+        return 5;
+      } else if (lineBreak1 || lineBreak2) {
+        return 4;
+      } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
+        return 3;
+      } else if (whitespace1 || whitespace2) {
+        return 2;
+      } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
+        return 1;
+      }
+      return 0;
+    }
+    var pointer = 1;
+    while (pointer < diffs.length - 1) {
+      if (diffs[pointer - 1][0] == DIFF_EQUAL && diffs[pointer + 1][0] == DIFF_EQUAL) {
+        var equality1 = diffs[pointer - 1][1];
+        var edit = diffs[pointer][1];
+        var equality2 = diffs[pointer + 1][1];
+        var commonOffset = diff_commonSuffix(equality1, edit);
+        if (commonOffset) {
+          var commonString = edit.substring(edit.length - commonOffset);
+          equality1 = equality1.substring(0, equality1.length - commonOffset);
+          edit = commonString + edit.substring(0, edit.length - commonOffset);
+          equality2 = commonString + equality2;
+        }
+        var bestEquality1 = equality1;
+        var bestEdit = edit;
+        var bestEquality2 = equality2;
+        var bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+        while (edit.charAt(0) === equality2.charAt(0)) {
+          equality1 += edit.charAt(0);
+          edit = edit.substring(1) + equality2.charAt(0);
+          equality2 = equality2.substring(1);
+          var score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+          if (score >= bestScore) {
+            bestScore = score;
+            bestEquality1 = equality1;
+            bestEdit = edit;
+            bestEquality2 = equality2;
+          }
+        }
+        if (diffs[pointer - 1][1] != bestEquality1) {
+          if (bestEquality1) {
+            diffs[pointer - 1][1] = bestEquality1;
+          } else {
+            diffs.splice(pointer - 1, 1);
+            pointer--;
+          }
+          diffs[pointer][1] = bestEdit;
+          if (bestEquality2) {
+            diffs[pointer + 1][1] = bestEquality2;
+          } else {
+            diffs.splice(pointer + 1, 1);
+            pointer--;
+          }
+        }
+      }
+      pointer++;
+    }
+  }
+  function diff_cleanupMerge(diffs, fix_unicode) {
+    diffs.push([DIFF_EQUAL, ""]);
+    var pointer = 0;
+    var count_delete = 0;
+    var count_insert = 0;
+    var text_delete = "";
+    var text_insert = "";
+    var commonlength;
+    while (pointer < diffs.length) {
+      if (pointer < diffs.length - 1 && !diffs[pointer][1]) {
+        diffs.splice(pointer, 1);
+        continue;
+      }
+      switch (diffs[pointer][0]) {
+        case DIFF_INSERT:
+          count_insert++;
+          text_insert += diffs[pointer][1];
+          pointer++;
+          break;
+        case DIFF_DELETE:
+          count_delete++;
+          text_delete += diffs[pointer][1];
+          pointer++;
+          break;
+        case DIFF_EQUAL:
+          var previous_equality = pointer - count_insert - count_delete - 1;
+          if (fix_unicode) {
+            if (previous_equality >= 0 && ends_with_pair_start(diffs[previous_equality][1])) {
+              var stray = diffs[previous_equality][1].slice(-1);
+              diffs[previous_equality][1] = diffs[previous_equality][1].slice(0, -1);
+              text_delete = stray + text_delete;
+              text_insert = stray + text_insert;
+              if (!diffs[previous_equality][1]) {
+                diffs.splice(previous_equality, 1);
+                pointer--;
+                var k = previous_equality - 1;
+                if (diffs[k] && diffs[k][0] === DIFF_INSERT) {
+                  count_insert++;
+                  text_insert = diffs[k][1] + text_insert;
+                  k--;
+                }
+                if (diffs[k] && diffs[k][0] === DIFF_DELETE) {
+                  count_delete++;
+                  text_delete = diffs[k][1] + text_delete;
+                  k--;
+                }
+                previous_equality = k;
+              }
+            }
+            if (starts_with_pair_end(diffs[pointer][1])) {
+              var stray = diffs[pointer][1].charAt(0);
+              diffs[pointer][1] = diffs[pointer][1].slice(1);
+              text_delete += stray;
+              text_insert += stray;
+            }
+          }
+          if (pointer < diffs.length - 1 && !diffs[pointer][1]) {
+            diffs.splice(pointer, 1);
+            break;
+          }
+          if (text_delete.length > 0 || text_insert.length > 0) {
+            if (text_delete.length > 0 && text_insert.length > 0) {
+              commonlength = diff_commonPrefix(text_insert, text_delete);
+              if (commonlength !== 0) {
+                if (previous_equality >= 0) {
+                  diffs[previous_equality][1] += text_insert.substring(0, commonlength);
+                } else {
+                  diffs.splice(0, 0, [
+                    DIFF_EQUAL,
+                    text_insert.substring(0, commonlength)
+                  ]);
+                  pointer++;
+                }
+                text_insert = text_insert.substring(commonlength);
+                text_delete = text_delete.substring(commonlength);
+              }
+              commonlength = diff_commonSuffix(text_insert, text_delete);
+              if (commonlength !== 0) {
+                diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];
+                text_insert = text_insert.substring(0, text_insert.length - commonlength);
+                text_delete = text_delete.substring(0, text_delete.length - commonlength);
+              }
+            }
+            var n = count_insert + count_delete;
+            if (text_delete.length === 0 && text_insert.length === 0) {
+              diffs.splice(pointer - n, n);
+              pointer = pointer - n;
+            } else if (text_delete.length === 0) {
+              diffs.splice(pointer - n, n, [DIFF_INSERT, text_insert]);
+              pointer = pointer - n + 1;
+            } else if (text_insert.length === 0) {
+              diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete]);
+              pointer = pointer - n + 1;
+            } else {
+              diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete], [DIFF_INSERT, text_insert]);
+              pointer = pointer - n + 2;
+            }
+          }
+          if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {
+            diffs[pointer - 1][1] += diffs[pointer][1];
+            diffs.splice(pointer, 1);
+          } else {
+            pointer++;
+          }
+          count_insert = 0;
+          count_delete = 0;
+          text_delete = "";
+          text_insert = "";
+          break;
+      }
+    }
+    if (diffs[diffs.length - 1][1] === "") {
+      diffs.pop();
+    }
+    var changes = false;
+    pointer = 1;
+    while (pointer < diffs.length - 1) {
+      if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+        if (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {
+          diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length);
+          diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+          diffs.splice(pointer - 1, 1);
+          changes = true;
+        } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == diffs[pointer + 1][1]) {
+          diffs[pointer - 1][1] += diffs[pointer + 1][1];
+          diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];
+          diffs.splice(pointer + 1, 1);
+          changes = true;
+        }
+      }
+      pointer++;
+    }
+    if (changes) {
+      diff_cleanupMerge(diffs, fix_unicode);
+    }
+  }
+  function is_surrogate_pair_start(charCode) {
+    return charCode >= 55296 && charCode <= 56319;
+  }
+  function is_surrogate_pair_end(charCode) {
+    return charCode >= 56320 && charCode <= 57343;
+  }
+  function starts_with_pair_end(str) {
+    return is_surrogate_pair_end(str.charCodeAt(0));
+  }
+  function ends_with_pair_start(str) {
+    return is_surrogate_pair_start(str.charCodeAt(str.length - 1));
+  }
+  function remove_empty_tuples(tuples) {
+    var ret = [];
+    for (var i = 0;i < tuples.length; i++) {
+      if (tuples[i][1].length > 0) {
+        ret.push(tuples[i]);
+      }
+    }
+    return ret;
+  }
+  function make_edit_splice(before, oldMiddle, newMiddle, after) {
+    if (ends_with_pair_start(before) || starts_with_pair_end(after)) {
+      return null;
+    }
+    return remove_empty_tuples([
+      [DIFF_EQUAL, before],
+      [DIFF_DELETE, oldMiddle],
+      [DIFF_INSERT, newMiddle],
+      [DIFF_EQUAL, after]
+    ]);
+  }
+  function find_cursor_edit_diff(oldText, newText, cursor_pos) {
+    var oldRange = typeof cursor_pos === "number" ? { index: cursor_pos, length: 0 } : cursor_pos.oldRange;
+    var newRange = typeof cursor_pos === "number" ? null : cursor_pos.newRange;
+    var oldLength = oldText.length;
+    var newLength = newText.length;
+    if (oldRange.length === 0 && (newRange === null || newRange.length === 0)) {
+      var oldCursor = oldRange.index;
+      var oldBefore = oldText.slice(0, oldCursor);
+      var oldAfter = oldText.slice(oldCursor);
+      var maybeNewCursor = newRange ? newRange.index : null;
+      editBefore: {
+        var newCursor = oldCursor + newLength - oldLength;
+        if (maybeNewCursor !== null && maybeNewCursor !== newCursor) {
+          break editBefore;
+        }
+        if (newCursor < 0 || newCursor > newLength) {
+          break editBefore;
+        }
+        var newBefore = newText.slice(0, newCursor);
+        var newAfter = newText.slice(newCursor);
+        if (newAfter !== oldAfter) {
+          break editBefore;
+        }
+        var prefixLength = Math.min(oldCursor, newCursor);
+        var oldPrefix = oldBefore.slice(0, prefixLength);
+        var newPrefix = newBefore.slice(0, prefixLength);
+        if (oldPrefix !== newPrefix) {
+          break editBefore;
+        }
+        var oldMiddle = oldBefore.slice(prefixLength);
+        var newMiddle = newBefore.slice(prefixLength);
+        return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldAfter);
+      }
+      editAfter: {
+        if (maybeNewCursor !== null && maybeNewCursor !== oldCursor) {
+          break editAfter;
+        }
+        var cursor = oldCursor;
+        var newBefore = newText.slice(0, cursor);
+        var newAfter = newText.slice(cursor);
+        if (newBefore !== oldBefore) {
+          break editAfter;
+        }
+        var suffixLength = Math.min(oldLength - cursor, newLength - cursor);
+        var oldSuffix = oldAfter.slice(oldAfter.length - suffixLength);
+        var newSuffix = newAfter.slice(newAfter.length - suffixLength);
+        if (oldSuffix !== newSuffix) {
+          break editAfter;
+        }
+        var oldMiddle = oldAfter.slice(0, oldAfter.length - suffixLength);
+        var newMiddle = newAfter.slice(0, newAfter.length - suffixLength);
+        return make_edit_splice(oldBefore, oldMiddle, newMiddle, oldSuffix);
+      }
+    }
+    if (oldRange.length > 0 && newRange && newRange.length === 0) {
+      replaceRange: {
+        var oldPrefix = oldText.slice(0, oldRange.index);
+        var oldSuffix = oldText.slice(oldRange.index + oldRange.length);
+        var prefixLength = oldPrefix.length;
+        var suffixLength = oldSuffix.length;
+        if (newLength < prefixLength + suffixLength) {
+          break replaceRange;
+        }
+        var newPrefix = newText.slice(0, prefixLength);
+        var newSuffix = newText.slice(newLength - suffixLength);
+        if (oldPrefix !== newPrefix || oldSuffix !== newSuffix) {
+          break replaceRange;
+        }
+        var oldMiddle = oldText.slice(prefixLength, oldLength - suffixLength);
+        var newMiddle = newText.slice(prefixLength, newLength - suffixLength);
+        return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldSuffix);
+      }
+    }
+    return null;
+  }
+  function diff(text1, text2, cursor_pos, cleanup) {
+    return diff_main(text1, text2, cursor_pos, cleanup, true);
+  }
+  diff.INSERT = DIFF_INSERT;
+  diff.DELETE = DIFF_DELETE;
+  diff.EQUAL = DIFF_EQUAL;
+  module.exports = diff;
+});
+
 // src/testing/memory-repo-files.ts
 var globMatcher = (pattern) => new RegExp(`^${pattern.replace(/\*\*\/|\*\*|\*|[.+^${}()|[\]\\]/g, (token) => {
   if (token === "**/")
@@ -5885,10 +6641,16 @@ var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
   $ZodBase64.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function base642(params) {
+  return _base64(ZodBase64, params);
+}
 var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
   $ZodBase64URL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function base64url2(params) {
+  return _base64url(ZodBase64URL, params);
+}
 var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
   $ZodE164.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -6536,12 +7298,36 @@ function preprocess(fn, schema) {
     out: schema
   });
 }
+// ../../node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/iso.js
+var exports_iso = {};
+__export(exports_iso, {
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
+});
+function datetime2(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+function date2(params) {
+  return _isoDate(ZodISODate, params);
+}
+function time2(params) {
+  return _isoTime(ZodISOTime, params);
+}
+function duration2(params) {
+  return _isoDuration(ZodISODuration, params);
+}
 // ../../node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
   bigint: () => bigint2,
   boolean: () => boolean3,
-  date: () => date2,
+  date: () => date3,
   number: () => number3,
   string: () => string3
 });
@@ -6557,7 +7343,7 @@ function boolean3(params) {
 function bigint2(params) {
   return _coercedBigint(ZodBigInt, params);
 }
-function date2(params) {
+function date3(params) {
   return _coercedDate(ZodDate, params);
 }
 // ../pstdio-api-contracts/src/activity.ts
@@ -6666,30 +7452,6 @@ var harnessLocalId = (id) => id.slice(id.lastIndexOf(".") + 1);
 var agentDetailsSchema = agentInfoSchema.extend({
   skills: agentSkillsLayoutSchema.extend({ globalDir: string2() }).optional()
 });
-// ../pstdio-sync-contracts/src/compatibility.ts
-var peerSchema = strictObject({
-  release: string2().min(1),
-  protocolVersions: array(number2().int().positive()).min(1),
-  supportedFeatures: array(string2().min(1)),
-  requiredFeatures: array(string2().min(1))
-});
-var protocolPeer = {
-  release: "contracts-v1",
-  protocolVersions: [1],
-  supportedFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"],
-  requiredFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"]
-};
-function negotiate(client, relay) {
-  const common = client.protocolVersions.includes(1) && relay.protocolVersions.includes(1);
-  const features = client.requiredFeatures.every((feature) => relay.supportedFeatures.includes(feature)) && relay.requiredFeatures.every((feature) => client.supportedFeatures.includes(feature));
-  if (common && features)
-    return { status: "compatible", protocolVersion: 1 };
-  return {
-    status: "unsupported-protocol",
-    recoverable: true,
-    action: "Update the local runtime or relay to a common protocol and required feature set. Local work remains saved; retry after updating."
-  };
-}
 // ../pstdio-sync-contracts/src/json.ts
 function isJson(value) {
   try {
@@ -6825,24 +7587,258 @@ async function fingerprint(value) {
   const digest = await crypto.subtle.digest("SHA-256", bytes);
   return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-async function sealMutation(body) {
-  const parsed = mutationSchema.parse({ ...body, fingerprint: "0".repeat(64) });
-  const { fingerprint: _ignored, ...normalized } = parsed;
-  return { ...normalized, fingerprint: await fingerprint(normalized) };
-}
-async function validateMutation(input) {
-  const mutation = mutationSchema.parse(input);
-  const { fingerprint: supplied, ...body } = mutation;
-  if (await fingerprint(body) !== supplied)
-    throw new Error("Payload fingerprint does not match");
-  return mutation;
-}
+
+// ../pstdio-sync-contracts/src/checkpoint.ts
+var writerPositionSchema = strictObject({
+  environmentId: identitySchema,
+  sequence: number2().int().positive()
+});
+var checkpointBodySchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  environmentId: identitySchema,
+  sequence: number2().int().positive(),
+  parents: array(identitySchema),
+  document: strictObject({ recordId: identitySchema, generation: revisionSchema, recoveryRevision: revisionSchema }),
+  changes: array(changeSchema).min(1),
+  resolution: resolutionSchema.optional(),
+  rebase: strictObject({
+    expectedSnapshotHash: fingerprintSchema,
+    sources: array(strictObject({ operationId: identitySchema, fingerprint: fingerprintSchema })).min(1)
+  }).optional()
+});
+var checkpointGroupSchema = checkpointBodySchema.extend({ fingerprint: fingerprintSchema }).superRefine((group, ctx) => {
+  checkGroup({ ...group, operationId: `${group.environmentId}:${group.sequence}` }, ctx);
+  const sources = group.rebase?.sources.map((source) => source.operationId) ?? [];
+  if (new Set(sources).size !== sources.length || sources.some((id) => !group.parents.includes(id)))
+    ctx.addIssue({ code: "custom", message: "Rebased sources must be unique captured parents" });
+  if (new Set(group.parents).size !== group.parents.length || group.parents.includes(`${group.environmentId}:${group.sequence}`))
+    ctx.addIssue({ code: "custom", message: "Checkpoint parents must be unique and cannot include itself" });
+  if (new Set(group.changes.map((change) => change.recordId)).size !== group.changes.length || !group.changes.some((change) => change.recordId === group.document.recordId && change.shared?.kind === "text"))
+    ctx.addIssue({ code: "custom", message: "Checkpoint needs a document delta and unique projection records" });
+});
+var coverageAckSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  environmentId: identitySchema,
+  cut: revisionSchema,
+  snapshotHash: fingerprintSchema,
+  branches: array(identitySchema),
+  recovery: array(strictObject({
+    recordId: identitySchema,
+    generation: revisionSchema,
+    revision: revisionSchema,
+    checkpointRevision: revisionSchema,
+    baseCut: revisionSchema,
+    branches: array(identitySchema)
+  }).refine((recovery) => recovery.checkpointRevision <= recovery.revision, "Recovery checkpoint is in the future"))
+});
+var writerFrontierSchema = strictObject({ floor: revisionSchema });
+var recoveryFileSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  recordId: identitySchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  revision: revisionSchema,
+  checkpointRevision: revisionSchema,
+  state: string2(),
+  checkpointVector: string2(),
+  projectionBaseline: string2(),
+  frozen: strictObject({
+    identity: identitySchema,
+    revision: revisionSchema,
+    update: string2(),
+    vector: string2(),
+    group: checkpointGroupSchema.nullable(),
+    projectionBaseline: string2()
+  }).nullable()
+});
+var liveFrameSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  generation: revisionSchema,
+  kind: _enum(["update", "state-vector", "barrier"]),
+  payload: string2()
+});
+var backupCoverageSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  cut: revisionSchema,
+  snapshotHash: fingerprintSchema,
+  manifestHash: fingerprintSchema
+});
+var documentRotationSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  previousGeneration: revisionSchema,
+  generation: revisionSchema,
+  seed: string2()
+}).refine((rotation) => rotation.generation === rotation.previousGeneration + 1, "Document generation must advance once");
+var documentPositionSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  generation: revisionSchema,
+  position: string2()
+});
+// ../pstdio-sync-contracts/src/compatibility.ts
+var peerSchema = strictObject({
+  release: string2().min(1),
+  protocolVersions: array(number2().int().positive()).min(1),
+  supportedFeatures: array(string2().min(1)),
+  requiredFeatures: array(string2().min(1))
+});
 // ../pstdio-sync-contracts/src/identity.ts
 var environmentIdentitySchema = strictObject({ environmentId: identitySchema });
 var environmentTargetSchema = environmentIdentitySchema.extend({
   workbenchId: identitySchema,
   workspaceId: identitySchema
 });
+// ../pstdio-sync-contracts/src/protocol/envelopes.ts
+var syncIdSchema = string2().regex(/^[A-Za-z0-9_-]{16,128}$/);
+var sequenceSchema = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var byteLengthSchema = sequenceSchema;
+var payloadSchema = base642();
+var blobIdsSchema = array(syncIdSchema).max(1e5).refine((ids) => new Set(ids).size === ids.length, "Blob IDs must be unique");
+var spaceOwnerSchema = identitySchema.nullable();
+var updateEnvelopeSchema = strictObject({
+  updateId: syncIdSchema,
+  payload: payloadSchema,
+  blobIds: blobIdsSchema
+});
+var updateResultSchema = strictObject({ sequence: sequenceSchema.min(1), duplicate: boolean2() });
+var stateEnvelopeSchema = strictObject({
+  stateId: syncIdSchema,
+  baseStateId: syncIdSchema.nullable(),
+  through: sequenceSchema,
+  payload: payloadSchema,
+  summary: payloadSchema,
+  blobIds: blobIdsSchema
+});
+var stateInfoSchema = strictObject({
+  stateId: syncIdSchema,
+  baseStateId: syncIdSchema.nullable(),
+  through: sequenceSchema,
+  byteLength: byteLengthSchema,
+  summary: payloadSchema,
+  deviceId: identitySchema,
+  createdAt: exports_iso.datetime()
+});
+var stateResultSchema = strictObject({ state: stateInfoSchema });
+var storedUpdateSchema = strictObject({
+  sequence: sequenceSchema.min(1),
+  updateId: syncIdSchema,
+  deviceId: identitySchema,
+  payload: payloadSchema,
+  createdAt: exports_iso.datetime()
+});
+var readRequestSchema = strictObject({ after: sequenceSchema });
+var readResultSchema = discriminatedUnion("status", [
+  strictObject({
+    status: literal("updates"),
+    state: stateInfoSchema.nullable(),
+    lastSequence: sequenceSchema,
+    updates: array(storedUpdateSchema),
+    more: boolean2()
+  }),
+  strictObject({
+    status: literal("state-required"),
+    state: stateInfoSchema.nullable(),
+    lastSequence: sequenceSchema
+  })
+]);
+var blobBeginSchema = strictObject({ sha256: fingerprintSchema, byteLength: byteLengthSchema });
+var blobStatusSchema = strictObject({
+  partSize: number2().int().positive(),
+  completed: boolean2(),
+  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema }))
+});
+var blobReadSchema = strictObject({ offset: byteLengthSchema });
+var liveClientMessageSchema = strictObject({
+  type: literal("live"),
+  spaceOwner: spaceOwnerSchema,
+  payload: payloadSchema
+});
+var liveServerMessageSchema = discriminatedUnion("type", [
+  strictObject({ type: literal("ready"), protocolVersion: number2().int().positive() }),
+  strictObject({
+    type: literal("live"),
+    spaceOwner: spaceOwnerSchema,
+    deviceId: identitySchema,
+    payload: payloadSchema
+  }),
+  strictObject({
+    type: literal("changed"),
+    spaceOwner: spaceOwnerSchema,
+    documentId: syncIdSchema,
+    lastSequence: sequenceSchema,
+    stateId: syncIdSchema.nullable()
+  })
+]);
+var syncErrorSchema = discriminatedUnion("error", [
+  strictObject({
+    error: literal("protocol-unsupported"),
+    supported: array(number2().int()),
+    message: string2()
+  }),
+  strictObject({ error: literal("stale-state"), state: stateInfoSchema.nullable() }),
+  strictObject({ error: literal("missing-blobs"), blobIds: array(syncIdSchema) }),
+  strictObject({
+    error: _enum([
+      "invalid-request",
+      "unauthorized",
+      "forbidden",
+      "not-found",
+      "method-not-allowed",
+      "too-large",
+      "quota-exceeded",
+      "rate-limited",
+      "unavailable"
+    ])
+  })
+]);
+// ../pstdio-sync-contracts/src/protocol/keys.ts
+var spaceKeySchema = strictObject({
+  generation: number2().int().positive(),
+  secret: base64url2().length(43)
+});
+var spaceKeysSchema = strictObject({
+  project: array(spaceKeySchema).min(1),
+  personal: array(spaceKeySchema).min(1)
+});
+// ../pstdio-sync-contracts/src/protocol/routes.ts
+var space = { projectId: identitySchema, spaceOwner: identitySchema.nullable() };
+var routeSchema = discriminatedUnion("kind", [
+  strictObject({
+    kind: literal("document"),
+    ...space,
+    documentId: syncIdSchema,
+    operation: _enum(["updates", "read", "state"])
+  }),
+  strictObject({ kind: literal("state"), ...space, documentId: syncIdSchema, stateId: syncIdSchema }),
+  strictObject({
+    kind: literal("blob"),
+    ...space,
+    blobId: syncIdSchema,
+    operation: _enum(["begin", "finish", "read"])
+  }),
+  strictObject({
+    kind: literal("part"),
+    ...space,
+    blobId: syncIdSchema,
+    number: number2().int().min(1).max(1e4)
+  }),
+  strictObject({ kind: literal("live"), projectId: identitySchema })
+]);
 // ../pstdio-sync-contracts/src/state.ts
 var checkpointSchema = strictObject({ epoch: identitySchema, sequence: revisionSchema });
 var recordSchema = strictObject({
@@ -6919,6 +7915,44 @@ var replaySchema = strictObject({
       message: "Replay must contain contiguous complete accepted groups in one scope and epoch"
     });
 });
+// ../pstdio-sync-contracts/src/retention.ts
+var coveredReceiptSchema = strictObject({
+  group: checkpointGroupSchema,
+  status: _enum(["accepted", "pending", "conflict"]),
+  cut: revisionSchema.nullable()
+}).refine((receipt) => receipt.status === "accepted" === (receipt.cut !== null), "Only accepted receipts have a cut");
+var coveredSnapshotSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  cut: revisionSchema,
+  covered: revisionSchema,
+  records: dictionarySchema(recordSchema),
+  conflicts: dictionarySchema(conflictSchema),
+  publishedRevision: identitySchema,
+  documents: dictionarySchema(revisionSchema),
+  receipts: dictionarySchema(coveredReceiptSchema),
+  writers: dictionarySchema(writerFrontierSchema),
+  retainedBranches: array(identitySchema)
+});
+var recoveryCoverageSchema = strictObject({
+  recordId: identitySchema,
+  generation: revisionSchema,
+  revision: revisionSchema,
+  checkpointRevision: revisionSchema,
+  baseCut: revisionSchema,
+  branches: array(identitySchema)
+}).refine((recovery) => recovery.checkpointRevision <= recovery.revision, "Checkpoint cannot cover future recovery edits");
+var backupManifestSchema = strictObject({
+  protocolVersion: literal(2),
+  snapshot: coveredSnapshotSchema,
+  assets: array(assetSchema),
+  packages: array(assetSchema),
+  copiesScope: scopeSchema,
+  snapshotHash: fingerprintSchema,
+  coverage: array(coverageAckSchema)
+});
 // ../pstdio-sync-contracts/src/transport.ts
 var relayOperationSchema = _enum([
   "initialize",
@@ -6939,21 +7973,21 @@ var relayReplayResultSchema = discriminatedUnion("status", [
   strictObject({ status: literal("replay"), batch: replaySchema }),
   strictObject({ status: literal("snapshot-required"), checkpoint: checkpointSchema })
 ]);
-var byteLengthSchema = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var byteLengthSchema2 = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 var relayAssetBeginSchema = strictObject({ uploadId: identitySchema, asset: assetSchema });
 var relayAssetUploadSchema = strictObject({ uploadId: identitySchema });
 var relayAssetPartSchema = strictObject({
   uploadId: identitySchema,
   number: number2().int().min(1).max(1e4),
   sha256: fingerprintSchema,
-  byteLength: byteLengthSchema
+  byteLength: byteLengthSchema2
 });
-var relayAssetReadSchema = strictObject({ asset: assetSchema, offset: byteLengthSchema }).refine(({ asset, offset }) => offset <= asset.byteLength, "Offset exceeds the asset");
+var relayAssetReadSchema = strictObject({ asset: assetSchema, offset: byteLengthSchema2 }).refine(({ asset, offset }) => offset <= asset.byteLength, "Offset exceeds the asset");
 var relayAssetStatusSchema = strictObject({
   asset: assetSchema,
   partSize: number2().int().positive(),
   completed: boolean2(),
-  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema }))
+  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema2 }))
 });
 var relayEventSchema = strictObject({ protocolVersion: literal(1), type: _enum(["ready", "changed"]) });
 var relayInitializeSchema = strictObject({ publishedRevision: identitySchema });
@@ -7791,6 +8825,14 @@ var extensionRendererRecordBaseSchema = object({
   emptyDescription: localizableStringSchema.optional()
 });
 var extensionTreeRendererRecordSchema = extensionRendererRecordBaseSchema.extend({
+  structure: array(object({
+    id: string2(),
+    label: localizableStringSchema.optional(),
+    collapsible: boolean2().optional(),
+    hiddenByDefault: boolean2().optional(),
+    canHide: boolean2().optional(),
+    resourceNode: object({ id: string2(), icon: string2().optional() }).optional()
+  })).optional(),
   searchable: boolean2().optional(),
   searchPlaceholder: localizableStringSchema.optional(),
   headerHandlerId: string2().optional(),
@@ -8148,6 +9190,11 @@ var regionSizeSchema = object({
 });
 var regionSettingsSchema = object({
   showHeader: boolean2().optional(),
+  canOpen: boolean2().optional(),
+  canClose: boolean2().optional(),
+  acceptsTabs: boolean2().optional(),
+  resizable: boolean2().optional(),
+  floatable: boolean2().optional(),
   size: regionSizeSchema.optional(),
   collapsible: boolean2().optional(),
   alwaysShowTabs: boolean2().optional()
@@ -9569,13 +10616,15 @@ var serializeCommandError = (error) => {
   return result;
 };
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
-var EXTENSION_API_VERSION = "0.2.0";
+var EXTENSION_API_VERSION = "0.2.1";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
 var WEBVIEW_HOST_CAPABILITY_VERSION = 1;
 var WEBVIEW_DECLARABLE_CAPABILITIES = [
   "clipboard.write",
   "commands.execute",
   "commands.stream",
+  "harnesses.read",
+  "resources.actions",
   "navigation.open",
   "page.params.update",
   "placement.close",
@@ -9898,6 +10947,10 @@ var reconcileMessageHistory = (input, projection = {}) => {
     throw error;
   }
 };
+// ../pstdio-api-contracts/src/link-icons.ts
+var linkIconSchema = object({
+  data_url: string2()
+});
 // ../pstdio-api-contracts/src/pagination.ts
 var pageQuerySchema = object({ cursor: string2().optional(), limit: exports_coerce.number().optional() });
 // ../pstdio-api-contracts/src/session-request-values.ts
@@ -10876,131 +11929,6 @@ var createMemoryAssets = () => {
   return api;
 };
 
-// ../pstdio-sync/src/encoding.ts
-var encodeBytes = (bytes) => btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
-var decodeBytes = (encoded) => Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
-var encodeText = (text) => encodeBytes(new TextEncoder().encode(text));
-var decodeText = (encoded) => new TextDecoder().decode(decodeBytes(encoded));
-
-// ../pstdio-sync/src/namespaces.ts
-var storageRecordId = (namespace, recordId) => JSON.stringify([...namespace, recordId]);
-var scopeRecordStorage = (records, namespace) => {
-  return { id: (key) => storageRecordId(namespace, key), ...records };
-};
-var legacyNamespaceStorage = (records, namespace) => {
-  const prefix = `${JSON.stringify(namespace).slice(0, -1)},`;
-  const storedId = (id) => storageRecordId(namespace, id);
-  return {
-    read: (id) => records.read(storedId(id)),
-    list: async () => (await records.list()).filter((record) => record.recordId.startsWith(prefix)).map((record) => ({ ...record, recordId: JSON.parse(record.recordId).at(-1) })),
-    commit: (group) => records.commit({
-      ...group,
-      edits: group.edits.map((edit) => ({ ...edit, recordId: storedId(edit.recordId) }))
-    })
-  };
-};
-
-// ../pstdio-sync/src/graph.ts
-var orderOperations = (available, ids) => {
-  const remaining = new Set(ids);
-  const ordered = [];
-  while (remaining.size) {
-    const ready = [...remaining].filter((id) => available.get(id).parents.every((parent) => !remaining.has(parent)));
-    if (!ready.length)
-      throw new Error("Cyclic operation dependency");
-    for (const id of ready) {
-      ordered.push(available.get(id));
-      remaining.delete(id);
-    }
-  }
-  return ordered;
-};
-
-// ../pstdio-sync/src/journal.ts
-var completedOperations = (snapshot) => {
-  const completed = new Set;
-  for (const receipt of Object.values(snapshot?.receipts ?? {})) {
-    if (receipt.status !== "accepted")
-      continue;
-    completed.add(receipt.operationId);
-    for (const captured of receipt.mutation.resolution?.capturedOperationIds ?? [])
-      completed.add(captured);
-  }
-  return completed;
-};
-var retainAcceptance = (entry, receipt) => {
-  if (receipt.recoveryProof)
-    entry.recoveryProof = receipt.recoveryProof;
-  if (receipt.status !== "accepted" || !receipt.checkpoint)
-    return;
-  const next = { fingerprint: receipt.fingerprint, order: receipt.order, checkpoint: receipt.checkpoint };
-  const previous = entry.acceptance;
-  if (previous?.fingerprint === next.fingerprint && previous.order === next.order && previous.checkpoint.epoch === next.checkpoint.epoch && previous.checkpoint.sequence === next.checkpoint.sequence)
-    return;
-  entry.acceptance = next;
-};
-var checkScope = (state, scope) => {
-  if (scope.workbenchId !== state.owner.workbenchId || scope.extensionId !== state.owner.extensionId)
-    throw new Error("Relay scope belongs to another storage owner");
-  if (state.accepted && canonicalJson(state.accepted.scope) !== canonicalJson(scope))
-    throw new Error("Storage is already bound to another account");
-};
-var sealOperation = async (state, operation) => {
-  if (!state.accepted)
-    throw new Error("Storage has not received a relay snapshot");
-  return sealMutation({ ...operation, protocolVersion: 1, scope: state.accepted.scope });
-};
-var snapshotVersion = (snapshot) => snapshot && canonicalJson(snapshot);
-var receiveSnapshot = async (state, snapshot, observed) => {
-  checkScope(state, snapshot.scope);
-  if (snapshotVersion(state.accepted) !== snapshotVersion(observed))
-    return;
-  if (state.accepted?.checkpoint.epoch === snapshot.checkpoint.epoch && (snapshot.journalSequence < state.accepted.journalSequence || snapshot.checkpoint.sequence < state.accepted.checkpoint.sequence))
-    return;
-  for (const receipt of Object.values(snapshot.receipts)) {
-    let entry = state.journal.find((entry) => entry.mutation.operationId === receipt.operationId);
-    if (entry) {
-      const sealed = await sealMutation({ ...entry.mutation, protocolVersion: 1, scope: snapshot.scope });
-      if (sealed.fingerprint !== receipt.fingerprint)
-        throw new Error("Received operation identity has changed content");
-    } else {
-      const { operationId, environmentId, parents, changes, resolution } = receipt.mutation;
-      entry = {
-        inputFingerprint: receipt.fingerprint,
-        mutation: { operationId, environmentId, parents, changes, resolution }
-      };
-      state.journal.push(entry);
-    }
-    retainAcceptance(entry, receipt);
-  }
-  state.accepted = snapshot;
-};
-var pendingOperations = (state, environmentId) => {
-  const completed = completedOperations(state.accepted);
-  const entries = new Map(state.journal.map((entry) => [entry.mutation.operationId, entry]));
-  const recovery = new Set;
-  const visit = (id) => {
-    if (completed.has(id) || recovery.has(id))
-      return;
-    const entry = entries.get(id);
-    if (!entry)
-      throw new Error("Journal dependency is unavailable");
-    recovery.add(id);
-    for (const parent of entry.mutation.parents)
-      visit(parent);
-  };
-  for (const entry of state.journal)
-    if (entry.acceptance && !completed.has(entry.mutation.operationId))
-      visit(entry.mutation.operationId);
-  const ordered = orderOperations(new Map([...entries].map(([id, entry]) => [id, entry.mutation])), recovery);
-  for (const entry of state.journal) {
-    const mutation = entry.mutation;
-    if (mutation.environmentId === environmentId && !completed.has(mutation.operationId) && !recovery.has(mutation.operationId))
-      ordered.push(mutation);
-  }
-  return ordered;
-};
-
 // ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/map.js
 var create = () => new Map;
 var copy = (m) => {
@@ -11719,13 +12647,13 @@ var equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
 // ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/object.js
 var isObject2 = (o) => typeof o === "object";
 var assign = Object.assign;
-var keys = Object.keys;
+var keys2 = Object.keys;
 var forEach = (obj, f) => {
   for (const key in obj) {
     f(obj[key], key);
   }
 };
-var size = (obj) => keys(obj).length;
+var size = (obj) => keys2(obj).length;
 var isEmpty = (obj) => {
   for (const _k in obj) {
     return false;
@@ -13374,6 +14302,25 @@ var readStateVector = (decoder) => {
   return ss;
 };
 var decodeStateVector = (decodedState) => readStateVector(new DSDecoderV1(createDecoder(decodedState)));
+var writeStateVector = (encoder, sv) => {
+  writeVarUint(encoder.restEncoder, sv.size);
+  from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
+    writeVarUint(encoder.restEncoder, client);
+    writeVarUint(encoder.restEncoder, clock);
+  });
+  return encoder;
+};
+var writeDocumentStateVector = (encoder, doc) => writeStateVector(encoder, getStateVector(doc.store));
+var encodeStateVectorV2 = (doc, encoder = new DSEncoderV2) => {
+  if (doc instanceof Map) {
+    writeStateVector(encoder, doc);
+  } else {
+    writeDocumentStateVector(encoder, doc);
+  }
+  return encoder.toUint8Array();
+};
+var encodeStateVector = (doc) => encodeStateVectorV2(doc, new DSEncoderV1);
+
 class EventHandler {
   constructor() {
     this.l = [];
@@ -13795,6 +14742,20 @@ class LazyStructReader {
     return this.curr;
   }
 }
+var decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1);
+var decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
+  const structs = [];
+  const updateDecoder = new YDecoder(createDecoder(update));
+  const lazyDecoder = new LazyStructReader(updateDecoder, false);
+  for (let curr = lazyDecoder.curr;curr !== null; curr = lazyDecoder.next()) {
+    structs.push(curr);
+  }
+  return {
+    structs,
+    ds: readDeleteSet(updateDecoder)
+  };
+};
+
 class LazyStructWriter {
   constructor(encoder) {
     this.currClient = 0;
@@ -14232,6 +15193,16 @@ var updateMarkerChanges = (searchMarker, index, len) => {
     }
   }
 };
+var getTypeChildren = (t) => {
+  t.doc ?? warnPrematureAccess();
+  let s = t._start;
+  const arr = [];
+  while (s) {
+    arr.push(s);
+    s = s.right;
+  }
+  return arr;
+};
 var callTypeObservers = (type, transaction, event) => {
   const changedType = type;
   const changedParentTypes = transaction.changedParentTypes;
@@ -16823,813 +17794,507 @@ if (glo[importIdentifier] === true) {
 }
 glo[importIdentifier] = true;
 
-// ../pstdio-sync/src/records.ts
-var put = (target, key, value) => Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
-var blankRecord = (recordId) => {
-  const record = {
-    recordId,
-    revision: 0,
-    deleted: false,
-    primitive: null,
-    map: {},
-    value: null,
-    asset: null
+// ../pstdio-sync/src/document-types.ts
+var memoryDocumentState = (document2) => {
+  const operations = new Map;
+  return {
+    document: document2,
+    operation: async (id) => operations.get(id),
+    remember: (id, fingerprint) => {
+      operations.set(id, fingerprint);
+    }
   };
-  return record;
 };
-var openDocument = (record) => {
-  const document2 = new Doc2;
-  if (record.shared)
-    applyUpdate(document2, decodeBytes(record.shared.update));
-  return document2;
-};
-var sharedValue = (record) => {
-  if (record.primitive === "map")
-    return { kind: "map", value: structuredClone(record.map) };
-  if (!record.primitive)
-    return null;
-  const document2 = openDocument(record);
-  try {
-    if (record.primitive === "text")
-      return { kind: "text", value: document2.getText("body").toString() };
-    return { kind: "list", value: document2.getArray("items").toArray() };
-  } finally {
-    document2.destroy();
-  }
-};
-var publicRecord = (record) => ({
-  recordId: record.recordId,
-  exists: record.revision > 0,
-  value: structuredClone(record.value),
-  asset: structuredClone(record.asset),
-  deleted: record.deleted,
-  shared: sharedValue(record)
-});
-var cellFingerprint = (map, key) => fingerprint({ exists: Object.hasOwn(map, key), value: Object.hasOwn(map, key) ? map[key] : null });
-var recordConflict = async (record, change) => {
-  if (record.deleted !== change.baseDeleted)
-    return "delete versus edit";
-  if (change.deleted !== undefined && record.revision !== change.expectedRevision)
-    return "delete versus edit";
-  if (change.expectedRevision > record.revision)
-    return "unknown base revision";
-  if (change.asset && canonicalJson(record.asset) !== canonicalJson(change.asset.base) && canonicalJson(record.asset) !== canonicalJson(change.asset.next))
-    return "competing asset replacements";
-  if (change.value && await fingerprint(record.value) !== change.value.expected)
-    return "competing JSON replacements";
-  if (change.shared && record.primitive && change.shared.kind !== record.primitive)
-    return "incompatible shared primitive";
-  if (change.shared?.kind === "map") {
-    for (const entry of change.shared.entries)
-      if (await cellFingerprint(record.map, entry.key) !== entry.expected)
-        return "competing map key edits";
-  }
-};
-var applySequenceEdit = (document2, edit) => {
-  if (edit.kind === "text.insert")
-    document2.getText("body").insert(edit.index, edit.text);
-  if (edit.kind === "text.delete")
-    document2.getText("body").delete(edit.index, edit.count);
-  if (edit.kind === "list.insert")
-    document2.getArray("items").insert(edit.index, edit.values);
-  if (edit.kind === "list.delete")
-    document2.getArray("items").delete(edit.index, edit.count);
-};
-var sharedChange = async (record, edits) => {
-  const document2 = openDocument(record);
-  const entries = new Map;
-  let kind;
-  try {
-    for (const edit of edits) {
-      const nextKind = edit.kind.split(".")[0];
-      if (kind && kind !== nextKind)
-        throw new Error("One shared primitive per record");
-      kind = nextKind;
-      applySequenceEdit(document2, edit);
-      if (edit.kind === "map.set" || edit.kind === "map.delete") {
-        entries.set(edit.key, {
-          key: edit.key,
-          expected: await cellFingerprint(record.map, edit.key),
-          next: edit.kind === "map.set" ? { kind: "set", value: edit.value } : { kind: "delete" }
-        });
-      }
+
+// ../pstdio-sync/src/checkpoint-capture.ts
+async function captureCheckpoint(document2, owner, action, observer) {
+  const fork = new Doc2;
+  const baseline = encodeStateVector(document2);
+  applyUpdate(fork, encodeStateAsUpdate(document2));
+  const state = memoryDocumentState(fork);
+  const store = {
+    observer,
+    transaction: async (target, run) => {
+      if (target.workbenchId !== owner.workbenchId || target.extensionId !== owner.extensionId)
+        throw new Error("A checkpoint cannot cross its storage owner");
+      return run(state);
     }
-    if (!kind)
-      throw new Error("Empty shared edit");
-    if (kind === "map")
-      return { kind, entries: [...entries.values()] };
-    return { kind, update: encodeBytes(encodeStateAsUpdate(document2)) };
+  };
+  try {
+    const value = await action(store);
+    return { value, update: encodeStateAsUpdate(fork, baseline) };
   } finally {
-    document2.destroy();
+    fork.destroy();
   }
+}
+// ../pstdio-sync/src/document-history.ts
+var ranges = (items) => {
+  const merged = [];
+  for (const item of items.sort(([a, b], [c, d]) => a - c || b - d)) {
+    const previous = merged.at(-1);
+    if (previous && previous[0] === item[0] && previous[1] + previous[2] === item[1] && previous[3] === item[3])
+      previous[2] += item[2];
+    else
+      merged.push([...item]);
+  }
+  return JSON.stringify(merged);
 };
-var applyRecordChange = (record, change) => {
-  const next = structuredClone(record);
-  if (change.shared)
-    next.primitive = change.shared.kind;
-  if (change.shared?.kind === "map") {
-    for (const entry of change.shared.entries) {
-      if (entry.next.kind === "delete")
-        delete next.map[entry.key];
+var documentHistory = (document2) => {
+  const decoded = decodeUpdate(encodeStateAsUpdate(document2));
+  const clients = new Map;
+  for (const struct of decoded.structs) {
+    const items = clients.get(struct.id.client) ?? [];
+    items.push(struct);
+    clients.set(struct.id.client, items);
+  }
+  const itemAt = (id) => {
+    const items = clients.get(id.client) ?? [];
+    let low = 0;
+    let high = items.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (items[middle].id.clock + items[middle].length <= id.clock)
+        low = middle + 1;
       else
-        put(next.map, entry.key, entry.next.value);
+        high = middle;
     }
-  } else if (change.shared) {
-    const document2 = openDocument(record);
+    return items[low];
+  };
+  const addresses = new Map;
+  const address = (item) => {
+    const chain = [];
+    let current = item;
+    let result;
+    while (current) {
+      if (addresses.has(current)) {
+        result = addresses.get(current);
+        break;
+      }
+      chain.push(current);
+      if (typeof current.parent === "string") {
+        result = { parent: current.parent, key: current.parentSub };
+        break;
+      }
+      const origin = current.origin ?? current.rightOrigin;
+      const previous = origin && itemAt(origin);
+      current = previous instanceof Item ? previous : undefined;
+    }
+    for (const entry of chain)
+      addresses.set(entry, result);
+    return result;
+  };
+  const fieldRanges = new Map;
+  for (const item of decoded.structs) {
+    if (!(item instanceof Item))
+      continue;
+    const field = address(item);
+    if (!field || field.key === null)
+      continue;
+    const key = JSON.stringify([field.parent, field.key]);
+    const entries = fieldRanges.get(key) ?? [];
+    entries.push([item.id.client, item.id.clock, item.length, isDeleted(decoded.ds, item.id)]);
+    fieldRanges.set(key, entries);
+  }
+  const fields = new Map([...fieldRanges].map(([key, entries]) => [key, ranges(entries)]));
+  const sequences = new Map([...document2.share].map(([name, type]) => [
+    name,
+    ranges(getTypeChildren(type).map((item) => [item.id.client, item.id.clock, item.length, item.deleted]))
+  ]));
+  return { fields, sequences };
+};
+// ../pstdio-sync/src/document-author.ts
+var documentAuthorId = (key) => {
+  let first = 2166136261;
+  let second = 3339675911;
+  for (let index = 0;index < key.length; index++) {
+    first = Math.imul(first ^ key.charCodeAt(index), 16777619) >>> 0;
+    second = Math.imul(second ^ key.charCodeAt(index), 2246822519) >>> 0;
+  }
+  return 2 ** 48 + first * 65536 + (second >>> 16);
+};
+var migrationAuthor = (document2, seed, history) => {
+  if (!seed)
+    return;
+  const author = (parent, key, value, action) => {
+    const current = document2.getMap(parent).get(key);
+    let sequence = null;
+    if (current?.kind === "text")
+      sequence = history?.sequences.get(current.name) ?? null;
+    if (current?.kind === "list")
+      sequence = history?.sequences.get(`${current.name}:order`) ?? null;
+    const previous = document2.clientID;
+    document2.clientID = documentAuthorId(canonicalJson([seed, parent, key, history?.fields.get(JSON.stringify([parent, key])) ?? null, sequence, value]));
     try {
-      applyUpdate(document2, decodeBytes(change.shared.update));
-      next.shared = { kind: change.shared.kind, update: encodeBytes(encodeStateAsUpdate(document2)) };
+      return action();
     } finally {
-      document2.destroy();
+      document2.clientID = previous;
     }
-  }
-  if (change.value)
-    next.value = change.value.next;
-  if (change.asset)
-    next.asset = change.asset.next;
-  next.deleted = change.deleted ?? change.baseDeleted;
-  next.revision++;
-  return next;
-};
-
-// ../pstdio-sync/src/resolution-validation.ts
-var parentProblem = (state, operation, captured, visited) => {
-  for (const parent of operation.parents) {
-    if (captured.has(parent)) {
-      if (!visited.has(parent))
-        return "captured branch is not in ancestry order";
-    } else if (!state.availableParentIds.has(parent))
-      return "uncaptured unaccepted prerequisite";
-  }
-};
-var connectedSize = (operations, rootId) => {
-  const captured = new Set(operations.map((operation) => operation.operationId));
-  const edges = new Map;
-  for (const operation of operations) {
-    for (const parent of operation.parents.filter((id) => captured.has(id))) {
-      edges.set(operation.operationId, new Set([...edges.get(operation.operationId) ?? [], parent]));
-      edges.set(parent, new Set([...edges.get(parent) ?? [], operation.operationId]));
-    }
-  }
-  const connected = new Set([rootId]);
-  for (const id of connected)
-    for (const next of edges.get(id) ?? [])
-      connected.add(next);
-  return connected.size;
-};
-var captureProblem = (state, mutation) => {
-  const proposal = mutation.resolution;
-  const captured = new Set(proposal.capturedOperationIds);
-  if (!captured.has(proposal.conflictId))
-    return "resolution must capture its root conflict";
-  const visited = new Set;
-  const recordIds = new Set;
-  const operations = [];
-  for (const id of proposal.capturedOperationIds) {
-    const operation = state.operations.get(id);
-    if (!operation || state.acceptedOperationIds.has(id))
-      return "captured branch is unavailable";
-    const problem = parentProblem(state, operation, captured, visited);
-    if (problem)
-      return problem;
-    operations.push(operation);
-    visited.add(id);
-    for (const change of operation.changes)
-      recordIds.add(change.recordId);
-  }
-  if (connectedSize(operations, proposal.conflictId) !== captured.size)
-    return "unrelated captured operation";
-  if (recordIds.size !== mutation.changes.length || mutation.changes.some((change) => !recordIds.has(change.recordId)))
-    return "resolution omits captured records";
-};
-var validateResolution = (state, mutation) => {
-  const proposal = mutation.resolution;
-  if (!proposal)
-    return;
-  const root = state.conflicts.get(proposal.conflictId);
-  if (!root || root.resolvedBy)
-    return "stale conflict revision";
-  for (const expected of proposal.expectedConflicts) {
-    const conflict = state.conflicts.get(expected.conflictId);
-    if (!conflict || conflict.revision !== expected.revision)
-      return "stale conflict revision";
-  }
-  const captured = new Set(proposal.capturedOperationIds);
-  const affected = [...state.conflicts.values()].filter((conflict) => conflict.alternativeOperationIds.some((id) => captured.has(id)));
-  if (affected.length !== proposal.expectedConflicts.length || affected.some((conflict) => !proposal.expectedConflicts.some((entry) => entry.conflictId === conflict.conflictId)))
-    return "missing captured conflict revision";
-  if (proposal.handler && proposal.handler.publishedRevision !== state.publishedRevision)
-    return "stale published handler revision";
-  for (const expected of proposal.expectedInputs)
-    if (expected.revision !== (state.records.get(expected.recordId)?.revision ?? 0))
-      return "stale input revision";
-  for (const change of mutation.changes) {
-    const record = state.records.get(change.recordId) ?? blankRecord(change.recordId);
-    if (change.shared && record.primitive && change.shared.kind !== record.primitive)
-      return "incompatible shared primitive";
-  }
-  return captureProblem(state, mutation);
+  };
+  return author;
 };
 
-// ../pstdio-sync/src/resolution-preflight.ts
-var resolutionGuards = (state, current) => {
-  const conflicts = new Map(Object.values(state.accepted?.conflicts ?? {}).map((conflict) => [conflict.conflictId, conflict]));
-  for (const conflict of current)
-    conflicts.set(conflict.conflictId, conflict);
-  return conflicts;
-};
-var resolutionProblem = (view, state, mutation) => {
-  if (mutation.resolution && !view.conflicts.has(mutation.resolution.conflictId))
-    return "stale conflict revision";
-  return validateResolution({
-    records: view.records,
-    conflicts: resolutionGuards(state, view.conflicts.values()),
-    operations: new Map(state.journal.map((entry) => [entry.mutation.operationId, entry.mutation])),
-    acceptedOperationIds: new Set(Object.values(state.accepted?.receipts ?? {}).filter((receipt) => receipt.status === "accepted").map((receipt) => receipt.operationId)),
-    availableParentIds: new Set([...view.outcomes].filter(([, outcome]) => outcome.status !== "conflict").map(([id]) => id)),
-    publishedRevision: state.accepted?.publishedRevision
-  }, mutation);
-};
-var retainAfterResolution = (view, mutation) => {
-  const proposal = mutation.resolution;
-  const captured = new Set(proposal.capturedOperationIds);
-  for (const id of captured)
-    view.completed.add(id);
-  for (const expected of proposal.expectedConflicts) {
-    const conflict = view.conflicts.get(expected.conflictId);
-    if (!conflict)
-      continue;
-    view.conflicts.delete(expected.conflictId);
-    for (const alternative of conflict.alternatives) {
-      if (captured.has(alternative.operationId))
-        continue;
-      view.conflicts.set(alternative.operationId, {
-        conflictId: alternative.operationId,
-        revision: 1,
-        recordIds: alternative.records.map((record) => record.recordId),
-        alternativeOperationIds: [alternative.operationId],
-        reason: conflict.reason,
-        alternatives: [alternative]
-      });
+// ../pstdio-sync/src/document-values.ts
+var import_fast_diff = __toESM(require_diff(), 1);
+var readValue = (value, document2) => {
+  if (value === null || typeof value !== "object")
+    return value ?? null;
+  const reference = value;
+  if (reference.kind === "text")
+    return document2.getText(reference.name).toString();
+  if (reference.kind === "list") {
+    const items = document2.getMap(`${reference.name}:items`);
+    const order = document2.getArray(`${reference.name}:order`).toArray();
+    return order.filter((key, index) => items.has(key) && order.lastIndexOf(key) === index).map((key) => readValue(items.get(key), document2));
+  }
+  return Object.fromEntries([...document2.getMap(reference.name)].map(([key, entry]) => [key, readValue(entry, document2)]));
+};
+var writeText = (text, next) => {
+  let index = 0;
+  for (const [operation, value] of import_fast_diff.default(text.toString(), next)) {
+    if (operation === -1)
+      text.delete(index, value.length);
+    else {
+      if (operation === 1)
+        text.insert(index, value);
+      index += value.length;
     }
   }
 };
-
-// ../pstdio-sync/src/projection.ts
-var receiptOutcome = (state, receipt) => {
-  if (receipt.status === "accepted")
-    return { status: "synchronized", operationId: receipt.operationId, checkpoint: receipt.checkpoint };
-  if (receipt.status === "conflict")
-    return {
-      status: "conflict",
-      operationId: receipt.operationId,
-      conflictId: receipt.conflictId,
-      conflictRevision: state.accepted.conflicts[receipt.conflictId].revision
-    };
-  return {
-    status: "pending",
-    operationId: receipt.operationId,
-    reason: receipt.reason ?? "awaiting dependency"
-  };
-};
-var acceptedProjection = (state) => {
-  const records = new Map(Object.entries(structuredClone(state.accepted?.records ?? {})));
-  const operations = new Map;
-  const outcomes = new Map;
-  const receipts = Object.values(state.accepted?.receipts ?? {}).sort((left, right) => (left.checkpoint?.sequence ?? 0) - (right.checkpoint?.sequence ?? 0));
-  for (const receipt of receipts) {
-    outcomes.set(receipt.operationId, receiptOutcome(state, receipt));
-    if (receipt.status === "accepted")
-      for (const change of receipt.mutation.changes)
-        operations.set(change.recordId, [...operations.get(change.recordId) ?? [], receipt.operationId]);
-  }
-  return {
-    records,
-    operations,
-    outcomes,
-    applied: new Set(receipts.filter((receipt) => receipt.status === "accepted").map((receipt) => receipt.operationId)),
-    completed: completedOperations(state.accepted),
-    conflicts: new Map(Object.values(state.accepted?.conflicts ?? {}).filter((conflict) => !conflict.resolvedBy).map((conflict) => [
-      conflict.conflictId,
-      {
-        ...structuredClone(conflict),
-        reason: "Retained alternative",
-        alternatives: []
-      }
-    ]))
-  };
-};
-var addConflict = (view, mutation, conflictId, reason) => {
-  const conflict = view.conflicts.get(conflictId) ?? {
-    conflictId,
-    reason,
-    revision: 1,
-    recordIds: mutation.changes.map((change) => change.recordId),
-    alternativeOperationIds: [],
-    alternatives: []
-  };
-  if (!conflict.alternativeOperationIds.includes(mutation.operationId))
-    conflict.alternativeOperationIds.push(mutation.operationId);
-  conflict.alternatives.push({
-    operationId: mutation.operationId,
-    records: mutation.changes.map((change) => applyRecordChange(view.records.get(change.recordId) ?? blankRecord(change.recordId), change))
-  });
-  view.conflicts.set(conflictId, conflict);
-  view.outcomes.set(mutation.operationId, {
-    status: "conflict",
-    operationId: mutation.operationId,
-    conflictId,
-    conflictRevision: conflict.revision
+var listKeys = (values) => {
+  const seen = new Map;
+  return values.map((value) => {
+    const identity = value && typeof value === "object" && !Array.isArray(value) && "id" in value ? canonicalJson(["id", value.id]) : canonicalJson(["value", value]);
+    const occurrence = seen.get(identity) ?? 0;
+    seen.set(identity, occurrence + 1);
+    return canonicalJson([identity, occurrence]);
   });
 };
-var localOutcome = (state, entry) => {
-  const operationId = entry.mutation.operationId;
-  if (!state.accepted)
-    return { status: "saved-locally", operationId };
-  if (entry.acceptance?.checkpoint.epoch === state.accepted.checkpoint.epoch)
-    return { status: "synchronized", operationId, checkpoint: entry.acceptance.checkpoint };
-  return { status: "pending", operationId, reason: "awaiting relay acceptance" };
-};
-var operationProblem = async (view, state, mutation) => {
-  if (mutation.resolution)
-    return resolutionProblem(view, state, mutation);
-  const blocked = mutation.parents.map((id) => view.outcomes.get(id)).find((outcome) => outcome?.status === "conflict");
-  if (blocked)
-    return "Unaccepted dependency";
-  const problems = await Promise.all(mutation.changes.map((change) => recordConflict(view.records.get(change.recordId) ?? blankRecord(change.recordId), change)));
-  return problems.find((problem) => problem !== undefined);
-};
-var advanceConflicts = (view, mutation) => {
-  for (const conflict of view.conflicts.values())
-    if (mutation.changes.some((change) => conflict.recordIds.includes(change.recordId)))
-      conflict.revision++;
-};
-var waitingForParent = (view, mutation) => {
-  const captured = new Set(mutation.resolution?.capturedOperationIds ?? []);
-  return mutation.parents.some((id) => !captured.has(id) && !view.applied.has(id) && view.outcomes.get(id)?.status !== "conflict");
-};
-var applyOperation = (view, mutation) => {
-  if (mutation.resolution)
-    retainAfterResolution(view, mutation);
-  for (const change of mutation.changes) {
-    view.records.set(change.recordId, applyRecordChange(view.records.get(change.recordId) ?? blankRecord(change.recordId), change));
-    view.operations.set(change.recordId, [...view.operations.get(change.recordId) ?? [], mutation.operationId]);
-  }
-  view.applied.add(mutation.operationId);
-};
-var projectOperation = async (view, state, entry, environmentId) => {
-  const mutation = entry.mutation;
-  if (view.completed.has(mutation.operationId))
-    return;
-  const known = state.accepted?.receipts[mutation.operationId];
-  const retained = known?.status === "conflict" ? Object.values(state.accepted.conflicts).find((conflict) => !conflict.resolvedBy && conflict.alternativeOperationIds.includes(mutation.operationId)) : undefined;
-  if (mutation.environmentId !== environmentId && !entry.acceptance && known?.status !== "conflict")
-    return;
-  if (known?.status !== "conflict" && waitingForParent(view, mutation)) {
-    view.outcomes.set(mutation.operationId, {
-      status: "pending",
-      operationId: mutation.operationId,
-      reason: "awaiting dependency"
-    });
-    return;
-  }
-  const blocked = mutation.parents.map((id) => view.outcomes.get(id)).find((outcome) => outcome?.status === "conflict");
-  const problem = await operationProblem(view, state, mutation);
-  if (!known && !blocked)
-    advanceConflicts(view, mutation);
-  if (known?.status === "conflict" || problem) {
-    addConflict(view, mutation, retained?.conflictId ?? (mutation.resolution && view.conflicts.has(mutation.resolution.conflictId) ? mutation.resolution.conflictId : undefined) ?? blocked?.conflictId ?? mutation.operationId, problem ?? "Unaccepted dependency");
-    return;
-  }
-  applyOperation(view, mutation);
-  view.outcomes.set(mutation.operationId, localOutcome(state, entry));
-};
-var projectGroups = async (state, environmentId) => {
-  const view = acceptedProjection(state);
-  for (const entry of state.journal)
-    await projectOperation(view, state, entry, environmentId);
-  const read = (recordId) => ({
-    ...publicRecord(view.records.get(recordId) ?? blankRecord(recordId)),
-    revision: encodeText(JSON.stringify({ owner: state.owner, recordId, operations: view.operations.get(recordId) ?? [] }))
-  });
-  return {
-    read,
-    records: view.records,
-    operations: view.operations,
-    outcomes: view.outcomes,
-    conflicts: [...view.conflicts.values()],
-    completed: view.completed
-  };
-};
-
-// ../pstdio-sync/src/authoring.ts
-var recordVersion = (state, recordId, captured) => {
-  const token = JSON.parse(decodeText(captured));
-  if (token.owner.workbenchId !== state.owner.workbenchId || token.owner.extensionId !== state.owner.extensionId)
-    throw new Error("Revision belongs to another storage owner");
-  if (token.recordId !== recordId)
-    throw new Error("Revision belongs to another record");
-  let record = blankRecord(recordId);
-  for (const operationId of token.operations) {
-    const entry = state.journal.find((entry) => entry.mutation.operationId === operationId);
-    if (!entry)
-      throw new Error("Unknown record revision");
-    const change = entry.mutation.changes.find((change) => change.recordId === recordId);
-    if (change)
-      record = applyRecordChange(record, change);
-  }
-  return { record, operations: token.operations };
-};
-var authorGroup = async (state, input, environmentId) => {
-  const parents = new Set;
-  const { completed } = await projectGroups(state, environmentId);
-  const changes = await Promise.all(input.edits.map(async (edit) => {
-    const base = recordVersion(state, edit.recordId, edit.expectedRevision);
-    for (const id of base.operations)
-      if (!completed.has(id))
-        parents.add(id);
-    return {
-      recordId: edit.recordId,
-      expectedRevision: base.record.revision,
-      baseDeleted: base.record.deleted,
-      ...Object.hasOwn(edit, "replace") && {
-        value: { expected: await fingerprint(base.record.value), next: edit.replace }
-      },
-      ...edit.shared && { shared: await sharedChange(base.record, edit.shared) },
-      ...edit.asset !== undefined && { asset: { base: base.record.asset, next: edit.asset } },
-      ...edit.deleted !== undefined && { deleted: edit.deleted }
-    };
-  }));
-  return { operationId: input.operationId, environmentId, parents: [...parents], changes };
-};
-var inputFingerprint = (input) => fingerprint(input);
-var entryFor = async (state, input, environmentId) => ({
-  inputFingerprint: await inputFingerprint(input),
-  mutation: await authorGroup(state, input, environmentId)
-});
-
-// ../pstdio-sync/src/branches.ts
-var workingRecords = (state, environmentId) => {
-  const pending = pendingOperations(state, environmentId);
-  const replaced = new Set(pending.flatMap((operation) => operation.resolution?.capturedOperationIds ?? []));
-  const records = new Map(Object.entries(structuredClone(state.accepted?.records ?? {})));
-  for (const mutation of pending) {
-    if (replaced.has(mutation.operationId))
+var valueReference = (parent, key, kind, path) => {
+  const current = parent.get(key);
+  if (current?.kind === kind)
+    return current;
+  const reference = { kind, name: `${path.length}:${path}${key.length}:${key}:${kind}` };
+  parent.set(key, reference);
+  return reference;
+};
+var writeList = (document2, name, values, author) => {
+  const items = document2.getMap(`${name}:items`);
+  const order = document2.getArray(`${name}:order`);
+  const keys = listKeys(values);
+  const wanted = new Set(keys);
+  for (const key of items.keys())
+    if (!wanted.has(key))
+      items.delete(key);
+  for (let index = 0;index < keys.length; index++)
+    writeValue(items, keys[index], values[index], `${name}:items`, author);
+  const current = order.toArray();
+  for (let index = current.length - 1;index >= 0; index--) {
+    if (!wanted.has(current[index]) || current.lastIndexOf(current[index]) !== index)
+      order.delete(index, 1);
+  }
+  for (let index = 0;index < keys.length; index++) {
+    if (order.get(index) === keys[index])
       continue;
-    for (const change of mutation.changes)
-      records.set(change.recordId, applyRecordChange(records.get(change.recordId) ?? blankRecord(change.recordId), change));
-  }
-  return Object.fromEntries(records);
-};
-var ancestors = (state, operationId) => {
-  const available = new Map(state.journal.map((entry) => [entry.mutation.operationId, entry.mutation]));
-  const required = new Set([operationId]);
-  for (const id of required) {
-    const operation = available.get(id);
-    if (!operation)
-      throw new Error("Branch operation is unavailable");
-    for (const parent of operation.parents)
-      if (state.accepted?.receipts[parent]?.status !== "accepted")
-        required.add(parent);
-  }
-  return orderOperations(available, required);
-};
-var readBranch = async (state, environmentId, recordId, operationId) => {
-  const view = await projectGroups(state, environmentId);
-  const applied = new Set([...view.operations.values()].flat());
-  const branch = ancestors(state, operationId);
-  const replaced = new Set(branch.flatMap((mutation) => mutation.resolution?.capturedOperationIds ?? []));
-  for (const mutation of branch) {
-    if (replaced.has(mutation.operationId))
-      continue;
-    if (applied.has(mutation.operationId))
-      continue;
-    for (const change of mutation.changes) {
-      view.records.set(change.recordId, applyRecordChange(view.records.get(change.recordId) ?? blankRecord(change.recordId), change));
-      view.operations.set(change.recordId, [...view.operations.get(change.recordId) ?? [], mutation.operationId]);
-    }
-    applied.add(mutation.operationId);
+    const previous = order.toArray().indexOf(keys[index], index);
+    if (previous >= 0)
+      order.delete(previous, 1);
+    order.insert(index, [keys[index]]);
   }
-  return {
-    ...publicRecord(view.records.get(recordId) ?? blankRecord(recordId)),
-    revision: encodeText(JSON.stringify({ owner: state.owner, recordId, operations: view.operations.get(recordId) ?? [] }))
-  };
-};
-
-// ../pstdio-sync/src/capture.ts
-var captureBranch = (state, environmentId, rootId, published = new Set) => {
-  const available = new Map(state.journal.map((entry) => [entry.mutation.operationId, entry.mutation]));
-  const captured = new Set([rootId]);
-  const pending = pendingOperations(state, environmentId);
-  let changed = true;
-  while (changed) {
-    const before = captured.size;
-    for (const mutation of pending.filter((operation) => !published.has(operation.operationId)))
-      if (mutation.parents.some((parent) => captured.has(parent)))
-        captured.add(mutation.operationId);
-    for (const id of captured) {
-      const mutation = available.get(id);
-      if (!mutation)
-        throw new Error("Captured branch is unavailable");
-      for (const parent of mutation.parents)
-        if (state.accepted?.receipts[parent]?.status !== "accepted" && !published.has(parent))
-          captured.add(parent);
-    }
-    changed = captured.size !== before;
-  }
-  return orderOperations(available, captured);
 };
-
-// ../pstdio-sync/src/resolution.ts
-var inspectConflict = async (state, environmentId, conflictId) => {
-  const known = state.accepted?.conflicts[conflictId];
-  const view = await projectGroups(state, environmentId);
-  const conflict = view.conflicts.find((entry) => entry.conflictId === conflictId);
-  if (!conflict || "resolvedBy" in conflict && conflict.resolvedBy)
-    throw new Error("No unresolved conflict");
-  const published = new Set([...view.outcomes].filter(([, outcome]) => outcome.status !== "conflict").map(([id]) => id));
-  const branch = captureBranch(state, environmentId, conflictId, known ? undefined : published);
-  const captured = new Set(branch.map((mutation) => mutation.operationId));
-  const ids = [...new Set(branch.flatMap((mutation) => mutation.changes.map((change) => change.recordId)))];
-  const accepted = ids.map(view.read);
-  return {
-    conflictId,
-    revision: conflict.revision,
-    expectedConflicts: [...resolutionGuards(state, view.conflicts).values()].filter((entry) => entry.alternativeOperationIds.some((id) => captured.has(id))).map((entry) => ({ conflictId: entry.conflictId, revision: entry.revision })),
-    capturedOperationIds: [...captured],
-    expectedInputs: accepted.map(({ recordId, revision }) => ({ recordId, revision })),
-    accepted,
-    alternatives: await Promise.all(branch.map(async (mutation) => ({
-      operationId: mutation.operationId,
-      parents: mutation.parents,
-      records: await Promise.all(mutation.changes.map((change) => readBranch(state, environmentId, change.recordId, mutation.operationId)))
-    })))
-  };
-};
-var resolutionShared = async (current, draft, choose) => {
-  const selected = choose === "local" ? draft : current;
-  const source = choose === "remote" && current.primitive !== draft.primitive ? current : draft;
-  if (source.primitive !== "map")
-    return source.shared;
-  const keys = [...new Set([...Object.keys(source.map), ...Object.keys(current.map)])];
-  if (!keys.length)
+var writeValue = (parent, key, next, path, author) => {
+  const write = () => writeValueContent(parent, key, next, path, author);
+  if (author)
+    author(path, key, next, write);
+  else
+    write();
+};
+var writeValueContent = (parent, key, next, path, author) => {
+  const current = parent.get(key);
+  const document2 = parent.doc;
+  if (Array.isArray(next)) {
+    const reference = valueReference(parent, key, "list", path);
+    writeList(document2, reference.name, next, author);
+  } else if (next !== null && typeof next === "object") {
+    const reference = valueReference(parent, key, "object", path);
+    const map = document2.getMap(reference.name);
+    for (const field of map.keys())
+      if (!Object.hasOwn(next, field))
+        map.delete(field);
+    for (const [field, value] of Object.entries(next).sort(([a], [b]) => a.localeCompare(b)))
+      writeValue(map, field, value, reference.name, author);
+  } else if (typeof next === "string" && (next.includes(`
+`) || current && typeof current === "object" && ("kind" in current) && current.kind === "text")) {
+    const reference = valueReference(parent, key, "text", path);
+    if (typeof current === "string")
+      seedText(document2, reference.name, current);
+    writeText(document2.getText(reference.name), next);
+  } else if (current !== next)
+    parent.set(key, next);
+};
+var seedText = (document2, name, value) => {
+  const client = documentAuthorId(canonicalJson(["text-promotion", name, value]));
+  if (decodeStateVector(encodeStateVector(document2)).has(client))
     return;
-  const entries = await Promise.all(keys.map(async (key) => ({
-    key,
-    expected: await fingerprint(null),
-    next: Object.hasOwn(selected.map, key) ? { kind: "set", value: selected.map[key] } : { kind: "delete" }
-  })));
-  return { kind: "map", entries };
-};
-var resolutionEntry = async (state, input, environmentId) => {
-  const available = new Map(state.journal.map((entry) => [entry.mutation.operationId, entry.mutation]));
-  const branch = input.capturedOperationIds.map((id) => {
-    const operation = available.get(id);
-    if (!operation)
-      throw new Error("Captured branch is unavailable");
-    return operation;
-  });
-  const ids = [...new Set(branch.flatMap((mutation) => mutation.changes.map((change) => change.recordId)))];
-  if (input.expectedInputs.length !== ids.length)
-    throw new Error("Resolution inputs must cover every captured record");
-  const replaced = new Set(branch.flatMap((mutation) => mutation.resolution?.capturedOperationIds ?? []));
-  const current = new Map(ids.map((id) => {
-    const expected = input.expectedInputs.find((entry) => entry.recordId === id);
-    if (!expected)
-      throw new Error("Resolution input is unavailable");
-    return [id, recordVersion(state, id, expected.revision).record];
-  }));
-  const draft = new Map([...current].map(([id, record]) => [id, structuredClone(record)]));
-  for (const mutation of branch) {
-    if (replaced.has(mutation.operationId))
-      continue;
-    for (const change of mutation.changes)
-      draft.set(change.recordId, applyRecordChange(draft.get(change.recordId), change));
+  const author = document2.clientID;
+  document2.clientID = client;
+  try {
+    document2.getText(name).insert(0, value);
+  } finally {
+    document2.clientID = author;
   }
-  const changes = await Promise.all(ids.map(async (recordId) => {
-    const base = current.get(recordId);
-    const alternative = draft.get(recordId);
-    const selected = input.choose === "local" ? alternative : base;
-    return {
-      recordId,
-      expectedRevision: base.revision,
-      baseDeleted: base.deleted,
-      shared: await resolutionShared(base, alternative, input.choose),
-      value: { expected: await fingerprint(base.value), next: selected.value },
-      asset: { base: base.asset, next: selected.asset },
-      deleted: selected.deleted
-    };
-  }));
-  const mutation = {
-    operationId: input.operationId,
-    environmentId,
-    parents: input.capturedOperationIds,
-    changes,
-    resolution: {
-      conflictId: input.conflictId,
-      expectedConflicts: input.expectedConflicts,
-      capturedOperationIds: input.capturedOperationIds,
-      expectedInputs: ids.map((recordId) => ({ recordId, revision: current.get(recordId).revision })),
-      ...input.handler && { handler: input.handler }
-    }
-  };
-  return { inputFingerprint: await inputFingerprint(input), mutation };
 };
 
-// ../pstdio-sync/src/asset-transfer.ts
-class MissingRemoteAsset extends Error {
-}
-var uploadMutationAssets = async (local, adapter, mutation) => {
-  for (const change of mutation.changes) {
-    const asset = change.asset?.next;
-    if (!asset)
-      continue;
-    if (!local || !adapter.assets)
-      throw new Error("Asset transport is unavailable");
-    await adapter.assets.put(asset, () => local.read(asset));
+// ../pstdio-sync/src/document-edits.ts
+var applyShared = (document2, record, name, shared, author) => {
+  const kind = shared.kind.split(".")[0];
+  if (record.get("sharedKind") !== kind)
+    record.set("sharedKind", kind);
+  switch (shared.kind) {
+    case "map.set":
+    case "map.delete": {
+      const reference = valueReference(record, "shared", "object", name);
+      const map = document2.getMap(reference.name);
+      if (shared.kind === "map.set")
+        writeValue(map, shared.key, shared.value, reference.name, author);
+      else
+        map.delete(shared.key);
+      break;
+    }
+    case "text.insert":
+    case "text.delete": {
+      const reference = valueReference(record, "shared", "text", name);
+      const text = document2.getText(reference.name);
+      if (shared.kind === "text.insert")
+        text.insert(shared.index, shared.text);
+      else
+        text.delete(shared.index, shared.count);
+      break;
+    }
+    case "list.insert":
+    case "list.delete": {
+      const values = record.has("shared") ? readValue(record.get("shared"), document2) : [];
+      if (shared.kind === "list.insert")
+        values.splice(shared.index, 0, ...shared.values);
+      else
+        values.splice(shared.index, shared.count);
+      writeValue(record, "shared", values, name, author);
+      break;
+    }
   }
 };
-var downloadAsset = async (local, adapter, asset, required) => {
-  if (!local) {
-    if (required)
-      throw new Error("Asset storage is unavailable");
-    return;
-  }
-  try {
-    await local.verifyComplete([asset]);
-    return;
-  } catch {}
-  if (!adapter.assets) {
-    if (required)
-      throw new Error("Asset transport is unavailable");
+var applyDocumentEdit = (document2, edit, author) => {
+  const records = document2.getMap("records");
+  if (edit.deleted) {
+    records.delete(edit.recordId);
+    document2.getMap("deleted").set(edit.recordId, true);
     return;
   }
-  try {
-    await local.receive(asset, async (offset, signal) => {
-      const source = await adapter.assets.get(asset, offset, signal);
-      if (!source)
-        throw new MissingRemoteAsset(`Required asset is incomplete: ${asset.sha256}`);
-      return source;
-    });
-  } catch (error) {
-    if (!required && error instanceof MissingRemoteAsset)
+  let name = records.get(edit.recordId);
+  if (!name) {
+    if (document2.getMap("deleted").has(edit.recordId) && edit.deleted !== false)
       return;
-    throw error;
+    name = JSON.stringify(["record", edit.recordId]);
+    records.set(edit.recordId, name);
+    document2.getMap("deleted").delete(edit.recordId);
+  }
+  const record = document2.getMap(name);
+  if (Object.hasOwn(edit, "replace"))
+    writeValue(record, "value", edit.replace, name, author);
+  if (edit.asset !== undefined && canonicalJson(record.get("asset") ?? null) !== canonicalJson(edit.asset))
+    record.set("asset", structuredClone(edit.asset));
+  for (const shared of edit.shared ?? []) {
+    const apply = () => applyShared(document2, record, name, shared, author);
+    if (author)
+      author(name, "shared", shared, apply);
+    else
+      apply();
   }
 };
-var downloadSnapshotAssets = async (local, adapter, snapshot) => {
-  const references = new Map;
-  for (const receipt of Object.values(snapshot.receipts)) {
-    for (const change of receipt.mutation.changes) {
-      const asset = change.asset?.next;
-      if (!asset)
-        continue;
-      const key = canonicalJson(asset);
-      references.set(key, { asset, required: receipt.status !== "pending" || references.get(key)?.required === true });
+
+// ../pstdio-sync/src/document-validation.ts
+var sequenceRange = (index, count, length) => {
+  if (!Number.isSafeInteger(index) || index < 0 || index > length || !Number.isSafeInteger(count) || count < 0 || index + count > length)
+    throw new Error("Shared edit is outside the current sequence");
+};
+var validateSequence = (value, shared) => {
+  switch (shared.kind) {
+    case "text.insert":
+    case "text.delete": {
+      const text = typeof value === "string" ? value : "";
+      const count = shared.kind === "text.delete" ? shared.count : 0;
+      sequenceRange(shared.index, count, text.length);
+      return text.slice(0, shared.index) + (shared.kind === "text.insert" ? shared.text : "") + text.slice(shared.index + count);
+    }
+    case "list.insert":
+    case "list.delete": {
+      const list = Array.isArray(value) ? value : [];
+      const count = shared.kind === "list.delete" ? shared.count : 0;
+      sequenceRange(shared.index, count, list.length);
+      list.splice(shared.index, count, ...shared.kind === "list.insert" ? shared.values : []);
+      return list;
     }
+    default:
+      return value;
+  }
+};
+var validateEdit = (document2, edit) => {
+  if (!Object.hasOwn(edit, "replace") && edit.asset === undefined && edit.deleted === undefined && !edit.shared?.length)
+    throw new Error("Empty record edit");
+  if (Object.hasOwn(edit, "replace"))
+    canonicalJson(edit.replace);
+  const name = document2.getMap("records").get(edit.recordId);
+  const record = name ? document2.getMap(name) : undefined;
+  let kind = record?.get("sharedKind");
+  let value = record ? readValue(record.get("shared"), document2) : null;
+  for (const shared of edit.shared ?? []) {
+    const nextKind = shared.kind.split(".")[0];
+    if (kind && kind !== nextKind)
+      throw new Error("One shared primitive per record");
+    kind = nextKind;
+    value = validateSequence(value, shared);
+  }
+};
+var validateDocumentGroup = (document2, group) => {
+  if (!group.operationId || !group.edits.length)
+    throw new Error("Empty storage commit");
+  const seen = new Set;
+  for (const edit of group.edits) {
+    if (!edit.recordId || seen.has(edit.recordId))
+      throw new Error("A commit must name each record once");
+    seen.add(edit.recordId);
+    validateEdit(document2, edit);
   }
-  for (const record of Object.values(snapshot.records))
-    if (record.asset)
-      references.set(canonicalJson(record.asset), { asset: record.asset, required: true });
-  for (const { asset, required } of references.values())
-    await downloadAsset(local, adapter, asset, required);
 };
 
-// ../pstdio-sync/src/synchronize.ts
-var synchronize = async (input, adapter) => {
-  const compatibility = negotiate(protocolPeer, adapter.peer ?? protocolPeer);
-  if (compatibility.status !== "compatible")
-    return { ...compatibility, outcomes: [] };
-  await input.store.transaction(input.owner, async (state) => checkScope(state, adapter.scope));
-  const receive = async () => {
-    const observed = await input.store.transaction(input.owner, async (state) => state.accepted);
-    const snapshot = snapshotSchema.parse(await adapter.snapshot());
-    if (canonicalJson(snapshot.scope) !== canonicalJson(adapter.scope))
-      throw new Error("Relay snapshot scope differs from its adapter");
-    for (const receipt of Object.values(snapshot.receipts))
-      await validateMutation(receipt.mutation);
-    await downloadSnapshotAssets(input.assets, adapter, snapshot);
-    await input.store.transaction(input.owner, (state) => receiveSnapshot(state, snapshot, observed));
+// ../pstdio-sync/src/document-storage.ts
+var outcome = (operationId) => ({
+  operationId,
+  state: "saved-locally",
+  status: "saved-locally"
+});
+var readRecord = async (document2, recordId) => {
+  const name = document2.getMap("records").get(recordId);
+  const record = name ? document2.getMap(name) : undefined;
+  const deleted = !record && document2.getMap("deleted").has(recordId);
+  const shared = record?.get("sharedKind");
+  const value = record ? readValue(record.get("value"), document2) : null;
+  const asset = structuredClone(record?.get("asset") ?? null);
+  const sharedValue = shared ? { kind: shared, value: readValue(record?.get("shared"), document2) } : null;
+  return {
+    recordId,
+    exists: !!record || deleted,
+    deleted,
+    value,
+    asset,
+    shared: sharedValue,
+    revision: await fingerprint({ value, asset, shared: sharedValue, deleted })
   };
-  await receive();
-  const pending = await input.store.transaction(input.owner, async (state) => Promise.all(pendingOperations(state, input.environmentId).map(async (operation) => ({
-    mutation: await sealOperation(state, operation),
-    proof: state.journal.find((entry) => entry.mutation.operationId === operation.operationId)?.recoveryProof
-  }))));
-  const outcomes = [];
-  for (const { mutation, proof } of pending) {
-    await uploadMutationAssets(input.assets, adapter, mutation);
-    const foreignRecovery = mutation.environmentId !== input.environmentId && adapter.recover;
-    if (foreignRecovery && !proof)
-      throw new Error("Relay recovery proof is unavailable for a retained operation");
-    const receipt = receiptSchema.parse(foreignRecovery ? await foreignRecovery(mutation, proof) : await adapter.submit(mutation));
-    await validateMutation(receipt.mutation);
-    if (receipt.operationId !== mutation.operationId || receipt.fingerprint !== mutation.fingerprint)
-      throw new Error("Relay receipt differs from the submitted operation");
-    await input.store.transaction(input.owner, async (state) => {
-      const entry = state.journal.find((entry) => entry.mutation.operationId === mutation.operationId);
-      retainAcceptance(entry, receipt);
-    });
-    outcomes.push(receipt);
-  }
-  await receive();
-  return input.store.transaction(input.owner, async (state) => {
-    const conflicts = Object.values(state.accepted?.conflicts ?? {}).some((conflict) => !conflict.resolvedBy);
-    if (conflicts)
-      return { status: "conflict", outcomes };
-    if (pendingOperations(state, input.environmentId).length)
-      return { status: "pending", outcomes };
-    return { status: "synchronized", outcomes };
-  });
 };
-
-// ../pstdio-sync/src/storage.ts
-var createRecordStorage = (input) => {
-  const readRecord = (record) => {
-    input.store.observer?.read(input.owner, record);
+var createDocumentStorage = (input) => {
+  const { owner, store } = input;
+  const observed = async (document2, id) => {
+    const record = await readRecord(document2, id);
+    store.observer?.read(owner, record);
     return record;
   };
   return {
-    synchronize: (adapter) => synchronize(input, adapter),
-    readState: () => input.store.transaction(input.owner, async (state) => {
-      const snapshot = structuredClone(state);
-      return {
-        ...snapshot,
-        pending: pendingOperations(snapshot, input.environmentId),
-        working: workingRecords(snapshot, input.environmentId)
-      };
+    dataVersion: (scope) => store.transaction(owner, async ({ document: document2 }) => {
+      const prefix = `${JSON.stringify([scope]).slice(0, -1)},`;
+      const versions = [...document2.getMap("data-migrations").keys()].filter((key) => key.startsWith(prefix));
+      return Math.max(0, ...versions.map((key) => JSON.parse(key)[1]));
     }),
-    mutation: (operationId) => input.store.transaction(input.owner, async (state) => {
-      const entry = state.journal.find((entry) => entry.mutation.operationId === operationId);
-      if (!entry)
-        throw new Error("Operation not found");
-      return sealOperation(state, entry.mutation);
+    setDataVersion: (scope, version) => store.transaction(owner, async ({ document: document2 }) => {
+      document2.getMap("data-migrations").set(JSON.stringify([scope, version]), true);
     }),
+    exportUpdate: () => store.transaction(owner, async ({ document: document2 }) => encodeStateAsUpdate(document2)),
+    applyUpdate: (update) => store.transaction(owner, async ({ document: document2 }) => {
+      applyUpdate(document2, update);
+    }),
+    capture: async (action) => {
+      const update = await store.transaction(owner, async ({ document: document2 }) => encodeStateAsUpdate(document2));
+      const snapshot = new Doc2;
+      applyUpdate(snapshot, update);
+      try {
+        return await captureCheckpoint(snapshot, owner, action, store.observer);
+      } finally {
+        snapshot.destroy();
+      }
+    },
     records: {
-      list: () => input.store.transaction(input.owner, async (state) => {
-        const view = await projectGroups(state, input.environmentId);
-        return [...view.records.keys()].filter((id) => !view.records.get(id).deleted).sort().map((id) => readRecord(view.read(id)));
-      }),
-      outcome: (operationId) => input.store.transaction(input.owner, async (state) => (await projectGroups(state, input.environmentId)).outcomes.get(operationId)),
-      inspect: (conflictId) => input.store.transaction(input.owner, (state) => inspectConflict(state, input.environmentId, conflictId)),
-      resolve: (proposal) => input.store.transaction(input.owner, async (state) => {
-        const previous = state.journal.find((entry) => entry.mutation.operationId === proposal.operationId);
-        if (previous && previous.inputFingerprint !== await inputFingerprint(proposal))
-          throw new Error("Operation identity reused with changed payload");
-        if (!previous) {
-          const entry = await resolutionEntry(state, proposal, input.environmentId);
-          localOperationSchema.parse(entry.mutation);
-          state.journal.push(entry);
-        }
-        return (await projectGroups(state, input.environmentId)).outcomes.get(proposal.operationId);
-      }),
-      read: (recordId, options) => input.store.transaction(input.owner, async (state) => {
-        if (!options)
-          return readRecord((await projectGroups(state, input.environmentId)).read(recordId));
-        return readBranch(state, input.environmentId, recordId, options.operationId);
-      }),
-      conflicts: () => input.store.transaction(input.owner, async (state) => (await projectGroups(state, input.environmentId)).conflicts.map(({ conflictId, revision, reason, recordIds, alternativeOperationIds }) => ({
-        conflictId,
-        revision,
-        reason,
-        recordIds,
-        alternativeOperationIds
-      }))),
-      commit: async (proposal) => {
-        const group = input.store.observer?.group(input.owner, proposal) ?? proposal;
+      read: (id, _branch) => store.transaction(owner, async ({ document: document2 }) => observed(document2, id)),
+      list: (prefix = "") => store.transaction(owner, async ({ document: document2 }) => Promise.all([...document2.getMap("records").keys()].filter((id) => id.startsWith(prefix)).sort().map((id) => observed(document2, id)))),
+      outcome: (id) => store.transaction(owner, async (state) => await state.operation(id) ? outcome(id) : undefined),
+      conflicts: async () => [],
+      inspect: (_id) => Promise.reject(new Error("Records merge automatically; there are no conflicts to inspect")),
+      resolve: (_proposal) => Promise.reject(new Error("Records merge automatically; there are no conflicts to resolve")),
+      commit: async (group) => {
+        if (!group.edits.length)
+          throw new Error("Empty storage commit");
         const assets = group.edits.flatMap((edit) => edit.asset ? [edit.asset] : []);
         if (assets.length) {
           if (!input.assets)
             throw new Error("Asset verification is unavailable");
           await input.assets.verifyComplete(assets);
         }
-        return input.store.transaction(input.owner, async (state) => {
-          const previous = state.journal.find((entry) => entry.mutation.operationId === group.operationId);
-          if (previous && previous.inputFingerprint !== await inputFingerprint(group))
+        const identity = await fingerprint(group.edits.map(({ expectedRevision: _revision, ...edit }) => edit));
+        const saved = await store.transaction(owner, async (state) => {
+          const doc = state.document;
+          const previous = await state.operation(group.operationId);
+          if (previous !== undefined && previous !== identity)
             throw new Error("Operation identity reused with changed payload");
-          if (!previous) {
-            const entry = await entryFor(state, group, input.environmentId);
-            localOperationSchema.parse(entry.mutation);
-            state.journal.push(entry);
+          if (previous === undefined) {
+            validateDocumentGroup(doc, group);
+            const author = migrationAuthor(doc, state.migrationSeed, state.migrationHistory);
+            doc.transact(() => {
+              for (const edit of group.edits)
+                applyDocumentEdit(doc, edit, author);
+            });
           }
-          const view = await projectGroups(state, input.environmentId);
-          const outcome = view.outcomes.get(group.operationId);
-          input.store.observer?.committed(input.owner, group.edits.map((edit) => view.read(edit.recordId)), outcome);
-          return outcome;
+          state.remember(group.operationId, identity);
+          return Promise.all(group.edits.map((edit) => readRecord(doc, edit.recordId)));
         });
+        const result = outcome(group.operationId);
+        store.observer?.committed(owner, saved, result);
+        return result;
       }
     }
   };
 };
+// ../pstdio-sync/src/encryption/sealing.ts
+var headerLength = 1 + 4 + 12;
+
+// ../pstdio-sync/src/encryption/space.ts
+var encoder = new TextEncoder;
+// ../pstdio-sync/src/namespaces.ts
+var storageRecordId = (namespace, recordId) => JSON.stringify([...namespace, recordId]);
+var scopeRecordStorage = (records, namespace) => {
+  return { id: (key) => storageRecordId(namespace, key), ...records };
+};
+var legacyNamespaceStorage = (records, namespace) => {
+  const prefix = `${JSON.stringify(namespace).slice(0, -1)},`;
+  const storedId = (id) => storageRecordId(namespace, id);
+  return {
+    read: (id) => records.read(storedId(id)),
+    list: async () => (await records.list(prefix)).map((record) => ({
+      ...record,
+      recordId: JSON.parse(record.recordId).at(-1)
+    })),
+    commit: (group) => records.commit({
+      ...group,
+      edits: group.edits.map((edit) => ({ ...edit, recordId: storedId(edit.recordId) }))
+    })
+  };
+};
 
 // ../pstdio-sync/src/legacy.ts
 var legacyJson = (value) => JSON.parse(JSON.stringify(value));
 var createLegacyRecordStorage = (input) => {
-  const within = (namespace, action) => input.store.transaction(input.owner, (state) => action(legacyNamespaceStorage(createRecordStorage({
+  const within = (namespace, action) => input.store.transaction(input.owner, (state) => action(legacyNamespaceStorage(createDocumentStorage({
     ...input,
     store: { transaction: async (_owner, run) => run(state), observer: input.store.observer }
   }).records, namespace)));
   const namespaceApi = (namespace) => {
+    const current = legacyNamespaceStorage(createDocumentStorage(input).records, namespace);
     const read = (records, id) => records.read(id);
     const replace = async (records, id, value, deleted = false) => {
       const current = await read(records, id);
@@ -17646,11 +18311,10 @@ var createLegacyRecordStorage = (input) => {
       });
     };
     return {
-      get: (id) => within(namespace, async (records) => {
-        const record = await read(records, id);
+      get: (id) => current.read(id).then((record) => {
         return record.exists && !record.deleted ? record.value : undefined;
       }),
-      list: () => within(namespace, (records) => records.list()),
+      list: () => current.list(),
       set: (id, value) => within(namespace, (records) => replace(records, id, value)),
       createIfAbsent: (id, value) => within(namespace, async (records) => {
         const current = await read(records, id);
@@ -17736,31 +18400,49 @@ var createLegacyRecordStorage = (input) => {
     }
   };
 };
-// src/testing/memory-record-owner.ts
-var createMemoryRecordOwner = (assets, seed = {}) => {
-  const owner = { workbenchId: crypto.randomUUID(), extensionId: "test-extension" };
-  const environmentId = crypto.randomUUID();
-  let state = { owner, accepted: null, journal: [] };
+// ../pstdio-sync/src/memory-document-store.ts
+var createMemoryDocumentStore = () => {
+  const document2 = new Doc2;
+  const state = memoryDocumentState(document2);
   let previous = Promise.resolve();
-  const baseStore = {
-    transaction: async (_owner, action) => {
-      const pending = previous;
-      let release = () => {};
-      previous = new Promise((resolve) => {
-        release = resolve;
-      });
+  let previousMigration = Promise.resolve();
+  const transaction = async (_owner, action) => {
+    const pending = previous;
+    const { promise, resolve } = Promise.withResolvers();
+    previous = promise;
+    await pending;
+    try {
+      return await action(state);
+    } finally {
+      resolve();
+    }
+  };
+  return {
+    transaction,
+    async duringMigration(key, run) {
+      const pending = previousMigration;
+      const { promise, resolve } = Promise.withResolvers();
+      previousMigration = promise;
       await pending;
+      const previousSeed = state.migrationSeed;
+      const previousHistory = state.migrationHistory;
+      state.migrationSeed = key;
+      state.migrationHistory = documentHistory(document2);
       try {
-        const draft = structuredClone(state);
-        const result = await action(draft);
-        state = draft;
-        return result;
+        return await run();
       } finally {
-        release();
+        state.migrationSeed = previousSeed;
+        state.migrationHistory = previousHistory;
+        resolve();
       }
     }
   };
-  const seedStorage = createLegacyRecordStorage({ store: baseStore, owner, environmentId }).scope("project", owner.workbenchId);
+};
+// src/testing/memory-record-owner.ts
+var createMemoryRecordOwner = (assets, seed = {}) => {
+  const owner = { workbenchId: crypto.randomUUID(), extensionId: "test-extension" };
+  const baseStore = createMemoryDocumentStore();
+  const seedStorage = createLegacyRecordStorage({ store: baseStore, owner }).scope("project", owner.workbenchId);
   const initialized = Promise.all([
     ...Object.entries(seed.kv ?? {}).map(([key, value]) => seedStorage.kv.set(key, value)),
     ...Object.entries(seed.collections ?? {}).flatMap(([name, items]) => Object.entries(items).map(([id, value]) => seedStorage.collection(name).set(id, value)))
@@ -17771,10 +18453,9 @@ var createMemoryRecordOwner = (assets, seed = {}) => {
       return baseStore.transaction(target, action);
     }
   };
-  const storage = createRecordStorage({
+  const storage = createDocumentStorage({
     store,
     owner,
-    environmentId,
     assets: {
       verifyComplete: assets.verifyComplete,
       read: assets.read,
@@ -17783,9 +18464,15 @@ var createMemoryRecordOwner = (assets, seed = {}) => {
       }
     }
   });
-  const legacy = createLegacyRecordStorage({ store, owner, environmentId });
+  const legacy = createLegacyRecordStorage({ store, owner });
   return {
     workbenchId: owner.workbenchId,
+    dataVersion: storage.dataVersion,
+    setDataVersion: storage.setDataVersion,
+    duringMigration: async (key, run) => {
+      await initialized;
+      return baseStore.duringMigration(key, run);
+    },
     scope: (type, id) => ({
       records: scopeRecordStorage(storage.records, [type, id, "kv"]),
       legacy: legacy.scope(type, id)
@@ -17803,12 +18490,9 @@ var createMemoryStorage = (options = {}) => {
     const existing = migrations.get(scope);
     if (existing)
       return existing;
-    let version = 0;
     const migrate = createDataMigrationRunner({
-      readVersion: async () => version,
-      writeVersion: async (next) => {
-        version = next;
-      }
+      readVersion: () => owner.dataVersion(scope),
+      writeVersion: (next) => owner.setDataVersion(scope, next)
     });
     migrations.set(scope, migrate);
     return migrate;
@@ -17868,7 +18552,7 @@ var createMemoryStorage = (options = {}) => {
     const { records, legacy } = owner.scope(scopeType, scopeId);
     const blobKey = JSON.stringify([scopeType, scopeId]);
     const api = {
-      migrate: migrateFor(blobKey),
+      migrate: (version, run) => migrateFor(blobKey)(version, (previous) => owner.duringMigration(JSON.stringify(["test-extension", scopeType, scopeId, version]), () => run(previous))),
       readLegacy: async (source) => structuredClone(options.legacyData?.[source]),
       records,
       assets,