@opendatalabs/personal-server-ts-server 1.27.0 → 1.29.0

package/dist/ui/ps-lite-debug.js

@@ -45302,7 +45302,7 @@ function FpSqrt(P11) {
     return sqrt5mod8;
   return tonelliShanks(P11);
 }
-function validateField(field) {
+function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
@@ -45313,7 +45313,7 @@ function validateField(field) {
     map2[val] = "function";
     return map2;
   }, initial);
-  return validateObject(field, opts);
+  return validateObject(field2, opts);
 }
 function FpPow(Fp2, num2, power) {
   if (power < _0n3)
@@ -45518,11 +45518,11 @@ function validateMSMPoints(points, c10) {
       throw new Error("invalid point at index " + i10);
   });
 }
-function validateMSMScalars(scalars, field) {
+function validateMSMScalars(scalars, field2) {
   if (!Array.isArray(scalars))
     throw new Error("array of scalars expected");
   scalars.forEach((s10, i10) => {
-    if (!field.isValid(s10))
+    if (!field2.isValid(s10))
       throw new Error("invalid scalar at index " + i10);
   });
 }
@@ -46827,13 +46827,13 @@ function hash_to_field(msg, count, options) {
   }
   return u10;
 }
-function isogenyMap(field, map2) {
+function isogenyMap(field2, map2) {
   const coeff = map2.map((i10) => Array.from(i10).reverse());
   return (x10, y10) => {
-    const [xn3, xd2, yn3, yd2] = coeff.map((val) => val.reduce((acc, i10) => field.add(field.mul(acc, x10), i10)));
-    const [xd_inv, yd_inv] = FpInvertBatch(field, [xd2, yd2], true);
-    x10 = field.mul(xn3, xd_inv);
-    y10 = field.mul(y10, field.mul(yn3, yd_inv));
+    const [xn3, xd2, yn3, yd2] = coeff.map((val) => val.reduce((acc, i10) => field2.add(field2.mul(acc, x10), i10)));
+    const [xd_inv, yd_inv] = FpInvertBatch(field2, [xd2, yd2], true);
+    x10 = field2.mul(xn3, xd_inv);
+    y10 = field2.mul(y10, field2.mul(yn3, yd_inv));
     return { x: x10, y: y10 };
   };
 }
@@ -60009,9 +60009,28 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isPort = RegExp.prototype.test.bind(/^\d*$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+    var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i10 = 0; i10 < 256; i10++) {
+        BYTE_HEX[i10] = "%" + HEX_DIGITS[i10 >> 4] + HEX_DIGITS[i10 & 15];
+      }
+    }
+    function percentEncodeNonAscii(cp2) {
+      if (cp2 < 2048) {
+        return BYTE_HEX[192 | cp2 >> 6] + BYTE_HEX[128 | cp2 & 63];
+      }
+      if (cp2 < 65536) {
+        return BYTE_HEX[224 | cp2 >> 12] + BYTE_HEX[128 | cp2 >> 6 & 63] + BYTE_HEX[128 | cp2 & 63];
+      }
+      return BYTE_HEX[240 | cp2 >> 18] + BYTE_HEX[128 | cp2 >> 12 & 63] + BYTE_HEX[128 | cp2 >> 6 & 63] + BYTE_HEX[128 | cp2 & 63];
+    }
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -60036,91 +60055,105 @@ var require_utils = __commonJS({
       }
       return acc;
     }
+    var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+    var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+    var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
     var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-    function consumeIsZone(buffer) {
-      buffer.length = 0;
-      return true;
-    }
-    function consumeHextets(buffer, address, output) {
-      if (buffer.length) {
-        const hex3 = stringArrayToHexStripped(buffer);
-        if (hex3 !== "") {
-          address.push(hex3);
-        } else {
-          output.error = true;
-          return false;
+    function isZoneIdentifier(zone) {
+      if (zone.length === 0) return false;
+      for (let i10 = 0; i10 < zone.length; i10++) {
+        if (isZoneCharacter(zone[i10])) continue;
+        if (zone[i10] === "%" && i10 + 2 < zone.length && isHexPair(zone.slice(i10 + 1, i10 + 3))) {
+          i10 += 2;
+          continue;
         }
-        buffer.length = 0;
+        return false;
       }
       return true;
     }
-    function getIPV6(input) {
-      let tokenCount = 0;
-      const output = { error: false, address: "", zone: "" };
-      const address = [];
-      const buffer = [];
-      let endipv6Encountered = false;
-      let endIpv6 = false;
-      let consume = consumeHextets;
-      for (let i10 = 0; i10 < input.length; i10++) {
-        const cursor = input[i10];
-        if (cursor === "[" || cursor === "]") {
-          continue;
-        }
-        if (cursor === ":") {
-          if (endipv6Encountered === true) {
-            endIpv6 = true;
-          }
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          if (++tokenCount > 7) {
-            output.error = true;
-            break;
+    function compressIPv6ZeroRun(hextets) {
+      let bestStart = -1;
+      let bestLength = 0;
+      let runStart = -1;
+      let runLength = 0;
+      for (let i10 = 0; i10 < hextets.length; i10++) {
+        if (hextets[i10] === "0") {
+          if (runStart === -1) runStart = i10;
+          runLength++;
+          if (runLength > bestLength) {
+            bestLength = runLength;
+            bestStart = runStart;
           }
-          if (i10 > 0 && input[i10 - 1] === ":") {
-            endipv6Encountered = true;
-          }
-          address.push(":");
-          continue;
-        } else if (cursor === "%") {
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          consume = consumeIsZone;
         } else {
-          buffer.push(cursor);
+          runStart = -1;
+          runLength = 0;
+        }
+      }
+      if (bestLength < 2) return hextets.join(":");
+      const head = hextets.slice(0, bestStart).join(":");
+      const tail = hextets.slice(bestStart + bestLength).join(":");
+      return head + "::" + tail;
+    }
+    function normalizeIPv6Address(input) {
+      const compression = input.indexOf("::");
+      if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+      const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+      const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+      if (compression !== -1) {
+        if (left.length === 1 && left[0] === "") left.length = 0;
+        if (right.length === 1 && right[0] === "") right.length = 0;
+      }
+      const parts = left.concat(right);
+      let hextetCount = 0;
+      for (let i10 = 0; i10 < parts.length; i10++) {
+        const part = parts[i10];
+        if (part === "") return void 0;
+        if (part.indexOf(".") !== -1) {
+          if (i10 !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          hextetCount += 2;
           continue;
         }
+        if (!isHextet(part)) return void 0;
+        parts[i10] = parseInt(part, 16).toString(16);
+        hextetCount++;
       }
-      if (buffer.length) {
-        if (consume === consumeIsZone) {
-          output.zone = buffer.join("");
-        } else if (endIpv6) {
-          address.push(buffer.join(""));
-        } else {
-          address.push(stringArrayToHexStripped(buffer));
-        }
+      if (compression === -1) {
+        if (hextetCount !== 8) return void 0;
+        return compressIPv6ZeroRun(parts);
       }
-      output.address = address.join("");
-      return output;
+      if (hextetCount >= 8) return void 0;
+      const expanded = parts.slice(0, left.length);
+      for (let i10 = hextetCount; i10 < 8; i10++) expanded.push("0");
+      for (let i10 = left.length; i10 < parts.length; i10++) expanded.push(parts[i10]);
+      return compressIPv6ZeroRun(expanded);
     }
     function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
-      }
-      const ipv63 = getIPV6(host);
-      if (!ipv63.error) {
-        let newHost = ipv63.address;
-        let escapedHost = ipv63.address;
-        if (ipv63.zone) {
-          newHost += "%" + ipv63.zone;
-          escapedHost += "%25" + ipv63.zone;
-        }
-        return { host: newHost, isIPV6: true, escapedHost };
-      } else {
-        return { host, isIPV6: false };
-      }
+      const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+      const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+      if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+      let input = bracketed ? host.slice(1, -1) : host;
+      if (bracketed && isIPvFuture(input)) {
+        input = input.toLowerCase();
+        return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+      }
+      if (findToken(input, ":") < 2) {
+        return { host, isIPV6: false, error: bracketed };
+      }
+      let zoneIdentifier = "";
+      const zoneSeparator = input.indexOf("%");
+      if (zoneSeparator !== -1) {
+        const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+        zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+        if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+        input = input.slice(0, zoneSeparator);
+      }
+      const address = normalizeIPv6Address(input);
+      if (address === void 0) return { host, isIPV6: false, error: true };
+      return {
+        host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+        escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+        isIPV6: true
+      };
     }
     function findToken(str, token) {
       let ind = 0;
@@ -60239,7 +60272,8 @@ var require_utils = __commonJS({
     function normalizePathEncoding(input) {
       let output = "";
       for (let i10 = 0; i10 < input.length; i10++) {
-        if (input[i10] === "%" && i10 + 2 < input.length) {
+        const ch3 = input[i10];
+        if (ch3 === "%" && i10 + 2 < input.length) {
           const hex3 = input.slice(i10 + 1, i10 + 3);
           if (isHexPair(hex3)) {
             const normalizedHex = hex3.toUpperCase();
@@ -60253,10 +60287,152 @@ var require_utils = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i10])) {
-          output += input[i10];
+        if (isPathCharacter(ch3)) {
+          output += ch3;
+        } else {
+          const code = input.charCodeAt(i10);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch3 : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i10 + 1 < input.length) {
+            const low = input.charCodeAt(i10 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i10++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function serializePathEncoding(input, pathNoScheme = false) {
+      let output = "";
+      let firstSegment = pathNoScheme && input[0] !== "/";
+      for (let i10 = 0; i10 < input.length; i10++) {
+        const ch3 = input[i10];
+        if (ch3 === "%" && i10 + 2 < input.length) {
+          const hex3 = input.slice(i10 + 1, i10 + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i10 += 2;
+            continue;
+          }
+        }
+        if (ch3 === "/") {
+          firstSegment = false;
+        }
+        if (isPathCharacter(ch3) && (ch3 !== ":" || !firstSegment)) {
+          output += ch3;
+        } else {
+          const code = input.charCodeAt(i10);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i10 + 1 < input.length) {
+            const low = input.charCodeAt(i10 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i10++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeComponent(input, isAllowed) {
+      let output = "";
+      for (let i10 = 0; i10 < input.length; i10++) {
+        const ch3 = input[i10];
+        if (ch3 === "%" && i10 + 2 < input.length) {
+          const hex3 = input.slice(i10 + 1, i10 + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i10 += 2;
+            continue;
+          }
+        }
+        if (isAllowed(ch3)) {
+          output += ch3;
         } else {
-          output += escape(input[i10]);
+          const code = input.charCodeAt(i10);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i10 + 1 < input.length) {
+            const low = input.charCodeAt(i10 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i10++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeUserinfo(input) {
+      return encodeComponent(input, isUserinfoCharacter);
+    }
+    function encodeQuery(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function encodeFragment(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function isEscapeSafe(cp2) {
+      return cp2 >= 48 && cp2 <= 57 || cp2 >= 65 && cp2 <= 90 || cp2 >= 97 && cp2 <= 122 || cp2 === 42 || cp2 === 43 || cp2 === 45 || cp2 === 46 || cp2 === 47 || cp2 === 64 || cp2 === 95;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i10 = 0; i10 < input.length; i10++) {
+        const ch3 = input[i10];
+        if (ch3 === "%" && i10 + 2 < input.length) {
+          const hex3 = input.slice(i10 + 1, i10 + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i10 += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch3)) {
+          output += ch3;
+        } else {
+          const code = input.charCodeAt(i10);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch3 : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i10 + 1 < input.length) {
+            const low = input.charCodeAt(i10 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i10++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -60279,14 +60455,18 @@ var require_utils = __commonJS({
     function recomposeAuthority(component) {
       const uriTokens = [];
       if (component.userinfo !== void 0) {
-        uriTokens.push(component.userinfo);
+        uriTokens.push(encodeUserinfo(component.userinfo));
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
+        let host = component.host;
         if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
-          if (ipV6res.isIPV6 === true) {
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
             host = reescapeHostDelimiters(host, false);
@@ -60295,8 +60475,12 @@ var require_utils = __commonJS({
         uriTokens.push(host);
       }
       if (typeof component.port === "number" || typeof component.port === "string") {
+        const port = String(component.port);
+        if (!isPort(port)) {
+          throw new TypeError("URI port is malformed.");
+        }
         uriTokens.push(":");
-        uriTokens.push(String(component.port));
+        uriTokens.push(port);
       }
       return uriTokens.length ? uriTokens.join("") : void 0;
     }
@@ -60306,6 +60490,11 @@ var require_utils = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      serializePathEncoding,
+      normalizeQueryFragmentEncoding,
+      encodeUserinfo,
+      encodeQuery,
+      encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
@@ -60321,7 +60510,7 @@ var require_schemes = __commonJS({
   "../../node_modules/fast-uri/lib/schemes.js"(exports, module2) {
     "use strict";
     var { isUUID } = require_utils();
-    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+    var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
     var supportedSchemeNames = (
       /** @type {const} */
       [
@@ -60382,9 +60571,10 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path, query] = wsComponent.resourceName.split("?");
+        const queryIndex = wsComponent.resourceName.indexOf("?");
+        const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
         wsComponent.path = path && path !== "/" ? path : void 0;
-        wsComponent.query = query;
+        wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
       wsComponent.fragment = void 0;
@@ -60396,7 +60586,7 @@ var require_schemes = __commonJS({
         return urnComponent;
       }
       const matches = urnComponent.path.match(URN_REG);
-      if (matches) {
+      if (matches && matches[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
         urnComponent.nid = matches[1].toLowerCase();
         urnComponent.nss = matches[2];
@@ -60530,8 +60720,17 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "../../node_modules/fast-uri/index.js"(exports, module2) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
+    var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+    var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+    function decodeValidScheme(scheme) {
+      const decodedScheme = unescape(String(scheme));
+      if (!VALID_SCHEME.test(decodedScheme)) {
+        throw new TypeError(MALFORMED_SCHEME_ERROR);
+      }
+      return decodedScheme;
+    }
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
@@ -60544,7 +60743,34 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const {
+        parsed: baseParsed,
+        malformedAuthorityOrPort: baseMalformed,
+        malformedPercentEncoding: baseMalformedPercentEncoding,
+        malformedSchemeSpecific: baseMalformedSchemeSpecific,
+        malformedHost: baseMalformedHost,
+        malformedScheme: baseMalformedScheme
+      } = parseWithStatus(baseURI, schemelessOptions);
+      const {
+        parsed: relativeParsed,
+        malformedAuthorityOrPort: relativeMalformed,
+        malformedPercentEncoding: relativeMalformedPercentEncoding,
+        malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+        malformedHost: relativeMalformedHost,
+        malformedScheme: relativeMalformedScheme
+      } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+      const resolvedHost = resolved.host;
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+      if (resolved.error && !encodedASCIIHost) {
+        throw new Error(resolved.error);
+      }
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -60604,7 +60830,7 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       const normalizedA = normalizeComparableURI(uriA, options);
       const normalizedB = normalizeComparableURI(uriB, options);
-      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -60625,19 +60851,22 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
+      if (component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
+      }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escapePreservingEscapes(component.path);
-          if (component.scheme !== void 0) {
-            component.path = component.path.split("%3A").join(":");
-          }
+          component.path = serializePathEncoding(component.path, pathNoScheme);
         } else {
           component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -60655,20 +60884,25 @@ var require_fast_uri = __commonJS({
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
           s10 = removeDotSegments(s10);
         }
+        if (pathNoScheme) {
+          s10 = serializePathEncoding(s10, true);
+        }
         if (authority === void 0 && s10[0] === "/" && s10[1] === "/") {
           s10 = "/%2F" + s10.slice(2);
         }
         uriTokens.push(s10);
       }
       if (component.query !== void 0) {
-        uriTokens.push("?", component.query);
+        uriTokens.push("?", encodeQuery(component.query));
       }
       if (component.fragment !== void 0) {
-        uriTokens.push("#", component.fragment);
+        uriTokens.push("#", encodeFragment(component.fragment));
       }
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+    var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -60678,6 +60912,35 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
+    function hasMalformedPercentEncoding(component) {
+      if (component === void 0) return false;
+      let percent = component.indexOf("%");
+      while (percent !== -1) {
+        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+          return true;
+        }
+        percent = component.indexOf("%", percent + 3);
+      }
+      return false;
+    }
+    function isIPLiteral(host) {
+      return host[0] === "[" && host[host.length - 1] === "]";
+    }
+    function hasMalformedComponentPercentEncoding(matches) {
+      const host = matches[4];
+      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    }
+    function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+        try {
+          parsed.host = new URL("http://" + parsed.host).hostname;
+        } catch (e10) {
+          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e10;
+          return true;
+        }
+      }
+      return false;
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -60690,6 +60953,11 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
+      let malformedPercentEncoding = false;
+      let malformedSchemeSpecific = false;
+      let malformedHost = false;
+      let malformedIPLiteral = false;
+      let malformedScheme = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -60698,6 +60966,25 @@ var require_fast_uri = __commonJS({
           uri = "//" + uri;
         }
       }
+      const authorityMatch = uri.match(AUTHORITY_PREFIX);
+      if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+        parsed.error = "URI authority must not contain a literal backslash.";
+        malformedAuthorityOrPort = true;
+      }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -60707,6 +60994,19 @@ var require_fast_uri = __commonJS({
         parsed.path = matches[6] || "";
         parsed.query = matches[7];
         parsed.fragment = matches[8];
+        if (parsed.scheme !== void 0) {
+          const decodedScheme = unescape(parsed.scheme);
+          if (VALID_SCHEME.test(decodedScheme)) {
+            parsed.scheme = decodedScheme.toLowerCase();
+          } else {
+            parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+            malformedScheme = true;
+          }
+        }
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        if (malformedPercentEncoding) {
+          parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+        }
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
@@ -60718,9 +61018,16 @@ var require_fast_uri = __commonJS({
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
+            const bracketedIPLiteral = isIPLiteral(parsed.host);
+            const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
             const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
-            isIP = ipv6result.isIPV6;
+            isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+            malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+            parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+            if (malformedIPLiteral) {
+              parsed.error = parsed.error || "URI host is malformed.";
+              malformedAuthorityOrPort = true;
+            }
           } else {
             isIP = true;
           }
@@ -60738,42 +61045,37 @@ var require_fast_uri = __commonJS({
           parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-            try {
-              parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
-            } catch (e10) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e10;
-            }
+        if (!malformedIPLiteral) {
+          malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+        }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP);
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
-            }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
-            }
-          }
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
           schemeHandler.parse(parsed, options);
+          if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+            malformedSchemeSpecific = true;
+          }
         }
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
     function parse3(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -60782,20 +61084,28 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-        malformedAuthorityOrPort
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort,
+        malformedPercentEncoding,
+        malformedSchemeSpecific,
+        malformedHost,
+        malformedScheme
       };
     }
     function normalizeComparableURI(uri, opts) {
-      if (typeof uri === "string") {
-        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-        return malformedAuthorityOrPort ? void 0 : normalized;
+      if (typeof uri !== "string" && typeof uri !== "object") {
+        return void 0;
       }
-      if (typeof uri === "object") {
-        return serialize(uri, opts);
+      let value;
+      try {
+        value = typeof uri === "string" ? uri : serialize(uri, opts);
+      } catch {
+        return void 0;
       }
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
       SCHEMES,
@@ -90109,24 +90419,24 @@ var hebNutrition = {
       if (["high", "medium", "low"].includes(String(n10.confidence))) {
         item.confidence = n10.confidence;
       }
-      for (const field of hebNutritionFields.slice(4, 19)) {
-        if (n10[field] === null || typeof n10[field] === "number") {
-          item[field] = n10[field];
+      for (const field2 of hebNutritionFields.slice(4, 19)) {
+        if (n10[field2] === null || typeof n10[field2] === "number") {
+          item[field2] = n10[field2];
         }
       }
       if (n10.serving_size === null || typeof n10.serving_size === "string")
         item.servingSize = n10.serving_size;
       if (n10.servings_per_container === null || typeof n10.servings_per_container === "string")
         item.servingsPerContainer = n10.servings_per_container;
-      for (const field of [
+      for (const field2 of [
         "upc",
         "ingredients",
         "allergens",
         "category",
         "highlights"
       ]) {
-        if (n10[field] !== void 0)
-          item[field] = n10[field];
+        if (n10[field2] !== void 0)
+          item[field2] = n10[field2];
       }
       const paddedProductId = n10.product_id.padStart(9, "0");
       item.images = {
@@ -90580,7 +90890,7 @@ var wholefoodsNutrition = {
       if (["high", "medium", "low"].includes(String(n10.confidence))) {
         item.confidence = n10.confidence;
       }
-      for (const field of [
+      for (const field2 of [
         "calories",
         "protein_g",
         "carbs_g",
@@ -90589,8 +90899,8 @@ var wholefoodsNutrition = {
         "fiber_g",
         "sugar_g"
       ]) {
-        if (n10[field] === null || typeof n10[field] === "number") {
-          item[field] = n10[field];
+        if (n10[field2] === null || typeof n10[field2] === "number") {
+          item[field2] = n10[field2];
         }
       }
       if (n10.serving_size === null || typeof n10.serving_size === "string")
@@ -90721,8 +91031,8 @@ var icloudNotes = {
     const notes = byStream(records, "notes").map((note) => {
       if (typeof note.id !== "string" || note.id.length === 0)
         return void 0;
-      const optionalString = (field) => {
-        const value = note[field];
+      const optionalString = (field2) => {
+        const value = note[field2];
         return value == null || typeof value === "string" ? value ?? null : void 0;
       };
       const title = optionalString("title");
@@ -90899,22 +91209,22 @@ function browserBinding(stream) {
           }
         };
       }
-      for (const field of requiredByStream[stream]) {
-        if (snapshot[field] === void 0 || snapshot[field] === null) {
+      for (const field2 of requiredByStream[stream]) {
+        if (snapshot[field2] === void 0 || snapshot[field2] === null) {
           return {
             ok: false,
             error: {
               kind: "incomplete_scope",
               scope,
-              reason: `${stream}.${field} is unavailable`
+              reason: `${stream}.${field2} is unavailable`
             }
           };
         }
       }
       const payload = {};
-      for (const field of fields) {
-        if (Object.hasOwn(snapshot, field))
-          payload[field] = snapshot[field];
+      for (const field2 of fields) {
+        if (Object.hasOwn(snapshot, field2))
+          payload[field2] = snapshot[field2];
       }
       if (stream === "events" && Object.hasOwn(payload, "windowDescription")) {
         payload.windowDescription = legacyEventsWindowDescription;
@@ -91211,7 +91521,7 @@ function inPrimaryKeyOrder(records, primaryKey) {
   const keyOf = (record2) => {
     const data = record2.data;
     const fields = primaryKey[record2.stream] ?? [];
-    return JSON.stringify(fields.map((field) => data && typeof data === "object" ? data[field] ?? null : null));
+    return JSON.stringify(fields.map((field2) => data && typeof data === "object" ? data[field2] ?? null : null));
   };
   return records.map((record2, index) => ({ record: record2, index, key: keyOf(record2) })).sort((a10, b10) => {
     if (a10.record.stream !== b10.record.stream)
@@ -91788,14 +92098,14 @@ function malformedCursor(message) {
     }
   };
 }
-function assertNonEmptyString(value, field) {
+function assertNonEmptyString(value, field2) {
   if (value.length === 0) {
-    throw new Error(`${field} must be a non-empty string`);
+    throw new Error(`${field2} must be a non-empty string`);
   }
 }
-function assertNonNegativeInteger(value, field) {
+function assertNonNegativeInteger(value, field2) {
   if (!isNonNegativeInteger(value)) {
-    throw new Error(`${field} must be a non-negative integer`);
+    throw new Error(`${field2} must be a non-negative integer`);
   }
 }
 function isNonNegativeInteger(value) {
@@ -92257,6 +92567,7 @@ function classifyStoredBody(scope, data) {
   return isProjectedScope(scope) && !data.records.some(isTaggedRecord) ? "pdpp-projected" : "pdpp-unprojected";
 }
 var SERVED = /* @__PURE__ */ Symbol.for("personal-server-ts.legacy-projection.served");
+var PROJECTED_VIEW = /* @__PURE__ */ Symbol.for("personal-server-ts.legacy-projection.projected-view");
 var textEncoder5 = new TextEncoder();
 var FORM_CACHE_SIZE = 64;
 function withLegacyProjection(raw, options = {}) {
@@ -92361,7 +92672,8 @@ function withLegacyProjection(raw, options = {}) {
     const envelope = { ...own, data: result.payload };
     return {
       envelope,
-      bytes: textEncoder5.encode(JSON.stringify(envelope))
+      bytes: textEncoder5.encode(JSON.stringify(envelope)),
+      ...result.diagnostics?.length ? { diagnostics: result.diagnostics } : {}
     };
   }
   async function builtBlocks(scope, view) {
@@ -92375,6 +92687,7 @@ function withLegacyProjection(raw, options = {}) {
   }
   const overrides = {
     [SERVED]: true,
+    [PROJECTED_VIEW]: projected,
     async readEnvelope(scope, collectedAt) {
       const { view, own } = await resolve(scope, collectedAt);
       return view?.envelope ?? own ?? raw.readEnvelope(scope, collectedAt);
@@ -92512,6 +92825,128 @@ function isRecordsBody(data) {
   const keys = Object.keys(data).filter((key) => !SERVER_STAMP_KEYS.has(key));
   return keys.length === 1 && keys[0] === "records" && Array.isArray(data.records);
 }
+async function supersedeLegacyVersions(storage, scope, committedAt) {
+  const refuse = (refused) => ({
+    superseded: [],
+    refused
+  });
+  const readStored = (storage.readStoredEnvelope ?? storage.readEnvelope).bind(storage);
+  const committed = await readStored(scope, committedAt);
+  if (classifyStoredBody(scope, committed.data) !== "pdpp-projected") {
+    return refuse("the new version is not PDPP records of a projected scope");
+  }
+  const projectedView = storage[PROJECTED_VIEW];
+  const view = projectedView ? await projectedView(scope, committedAt) : null;
+  if (!view)
+    return refuse("the new version cannot be projected");
+  if (view.diagnostics?.length) {
+    const kinds = [...new Set(view.diagnostics.map((d10) => d10.kind))];
+    return refuse(`the projection is partial (${kinds.join(", ")})`);
+  }
+  const collection = legacyCollectionKey(scope);
+  const projectedItems = view.envelope.data[collection];
+  const projectedCount = projectedItems.length;
+  const committedMs = Date.parse(committedAt);
+  const older = [];
+  const pageSize = 100;
+  for (let offset = 0; ; offset += pageSize) {
+    const page = storage.listVersions(scope, { limit: pageSize, offset });
+    for (const entry of page) {
+      if (Date.parse(entry.collectedAt) < committedMs) {
+        older.push(entry.collectedAt);
+      }
+    }
+    if (page.length < pageSize)
+      break;
+  }
+  const legacy = [];
+  for (const collectedAt of older) {
+    const envelope = await readStored(scope, collectedAt);
+    if (isBinaryEnvelope(envelope))
+      continue;
+    const items = legacyCollection(scope, envelope.data);
+    if (items === null)
+      continue;
+    legacy.push({
+      collectedAt,
+      count: items.length,
+      ids: items.map(itemId).filter((id2) => id2 !== void 0),
+      items
+    });
+  }
+  const newest = legacy.reduce((best, version4) => !best || Date.parse(version4.collectedAt) > Date.parse(best.collectedAt) ? version4 : best, void 0);
+  if (newest && projectedCount < newest.count) {
+    return refuse(`the projection has ${projectedCount} ${collection}; the newest legacy version has ${newest.count}`);
+  }
+  if (newest) {
+    const projectedIds = new Set(projectedItems.map(itemId).filter((id2) => id2 !== void 0));
+    const missing = newest.ids.filter((id2) => !projectedIds.has(id2));
+    if (missing.length > 0) {
+      return refuse(`the projection lacks ${missing.length} of the ${collection} in the newest legacy version`);
+    }
+    const shortfall = nestedShortfall(scope, newest.items, projectedItems);
+    if (shortfall)
+      return refuse(shortfall);
+  }
+  const superseded = [];
+  for (const { collectedAt } of legacy) {
+    if (await storage.deleteVersion(scope, collectedAt)) {
+      superseded.push(collectedAt);
+    }
+  }
+  return { superseded };
+}
+var NESTED_ITEMS = {
+  "claude.conversations": (item) => ({
+    held: arrayLength(field(item, "messages")),
+    selfShort: false
+  }),
+  "claude.projects": (item) => {
+    const detail = field(item, "detail");
+    const rawDocs = field(detail, "raw_docs");
+    const raw = Array.isArray(rawDocs) ? rawDocs : [];
+    const withId = raw.filter((doc) => typeof field(doc, "uuid") === "string");
+    const docs = arrayLength(field(detail, "docs"));
+    return {
+      held: docs + raw.length - withId.length,
+      selfShort: docs < withId.length
+    };
+  }
+};
+function field(value, key) {
+  return value !== null && typeof value === "object" ? value[key] : void 0;
+}
+function arrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function nestedShortfall(scope, legacyItems, projectedItems) {
+  const nested = NESTED_ITEMS[scope];
+  if (!nested)
+    return void 0;
+  const projectedById = new Map(projectedItems.map((item) => [itemId(item), nested(item).held]));
+  const short = legacyItems.filter((item) => (projectedById.get(itemId(item)) ?? 0) < nested(item).held);
+  const incomplete = projectedItems.filter((item) => nested(item).selfShort);
+  const count = short.length + incomplete.length;
+  return count > 0 ? `the projection holds fewer nested rows than the source or the newest legacy version for ${count} of the ${legacyCollectionKey(scope)}` : void 0;
+}
+function legacyCollectionKey(scope) {
+  return scope.slice(scope.indexOf(".") + 1);
+}
+function legacyCollection(scope, data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    return null;
+  }
+  if (isRecordsBody(data) || "$writtenBy" in data)
+    return null;
+  const items = data[legacyCollectionKey(scope)];
+  return Array.isArray(items) ? items : null;
+}
+function itemId(item) {
+  if (item === null || typeof item !== "object")
+    return void 0;
+  const { id: id2, uuid: uuid3 } = item;
+  return typeof id2 === "string" ? id2 : typeof uuid3 === "string" ? uuid3 : void 0;
+}
 
 // ../../node_modules/viem/_esm/index.js
 init_exports();
@@ -93400,12 +93835,12 @@ function hashStruct({ data, primaryType, types }) {
 function encodeData({ data, primaryType, types }) {
   const encodedTypes = [{ type: "bytes32" }];
   const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
+  for (const field2 of types[primaryType]) {
     const [type, value] = encodeField({
       types,
-      name: field.name,
-      type: field.type,
-      value: data[field.name]
+      name: field2.name,
+      type: field2.type,
+      value: data[field2.name]
     });
     encodedTypes.push(type);
     encodedValues.push(value);
@@ -93433,8 +93868,8 @@ function findTypeDependencies({ primaryType: primaryType_, types }, results = /*
     return results;
   }
   results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
+  for (const field2 of types[primaryType]) {
+    findTypeDependencies({ primaryType: field2.type, types }, results);
   }
   return results;
 }
@@ -97185,10 +97620,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
+      const field2 = shape[key]._zod;
+      if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v10 of field.values)
+        for (const v10 of field2.values)
           propValues[key].add(v10);
       }
     }
@@ -115112,6 +115547,25 @@ function encodePaymentResponseHeader(body) {
 function contractResponse(result) {
   return jsonResponse(result.body, { status: result.status });
 }
+async function supersedeAfterCommit(deps, scope, committedAt) {
+  try {
+    const result = await supersedeLegacyVersions(deps.storage, scope, committedAt);
+    if (result.superseded.length > 0) {
+      deps.logger?.info?.({ scope, committedAt, superseded: result.superseded }, "Deleted legacy-form versions superseded by a PDPP write");
+    }
+    if (result.refused) {
+      deps.logger?.info?.({ scope, committedAt, refused: result.refused }, "Kept legacy-form versions; superseding was refused");
+    }
+    return result;
+  } catch (err2) {
+    deps.logger?.warn?.({
+      scope,
+      committedAt,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    }, "Superseding legacy-form versions failed; the write is stored");
+    return { superseded: [], refused: "superseding failed" };
+  }
+}
 function contractErrorResponse(err2) {
   return jsonResponse(err2.body, { status: err2.status });
 }
@@ -115412,12 +115866,12 @@ function fireReadReport(deps, event, send) {
     warnReadFulfillmentReporterFailed(deps, event, err2);
   }
 }
-async function prepareWriteLineage(deps, scope, field) {
-  if (field === void 0 || field === null)
+async function prepareWriteLineage(deps, scope, field2) {
+  if (field2 === void 0 || field2 === null)
     return void 0;
   return prepareLineage({
     scope,
-    field,
+    field: field2,
     serverOwner: deps.serverOwner,
     storage: deps.storage,
     gateway: deps.lineageGateway,
@@ -115730,6 +116184,15 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       } else {
         await deps.auth.authorizeOwner(request2);
       }
+      const supersede = url2.searchParams.get("supersede");
+      if (supersede !== null && supersede !== "legacy") {
+        await writeAuth?.releaseProof?.();
+        return errorResponse(400, "INVALID_SUPERSEDE", 'supersede must be "legacy" or absent');
+      }
+      if (supersede !== null && writeAuth) {
+        await writeAuth.releaseProof?.();
+        return errorResponse(403, "FORBIDDEN", "Only the owner can supersede stored versions");
+      }
       let committed = false;
       let releaseStamp;
       const failWrite = async (response) => {
@@ -115769,6 +116232,9 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           }
         };
         if (!isJsonContentType(request2)) {
+          if (supersede !== null) {
+            return failWrite(errorResponse(400, "INVALID_SUPERSEDE", "supersede applies to JSON writes only"));
+          }
           const bytes2 = new Uint8Array(await request2.arrayBuffer());
           const metadata = parseMetadataHeader(request2.headers.get("x-vana-metadata"));
           const lineage2 = await prepareWriteLineage(deps, scopeResult.scope, extractLineageField(metadata));
@@ -115829,13 +116295,18 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           ...writeAuth ? { builder: writeAuth.builder } : {}
         }, "Data file ingested");
         await logBuilderWrite();
+        const supersedeResult = supersede === "legacy" ? await supersedeAfterCommit(deps, scopeResult.scope, collectedAtValue) : void 0;
         notifyNewData(deps.syncManager);
         notifyDataWritten(deps, {
           scope: scopeResult.scope,
           collectedAt: collectedAtValue,
           lineageSources: lineage?.sources
         });
-        return jsonResponse(result.response, { status: 201 });
+        return jsonResponse(supersedeResult ? {
+          ...result.response,
+          superseded: supersedeResult.superseded,
+          ...supersedeResult.refused ? { supersedeRefused: supersedeResult.refused } : {}
+        } : result.response, { status: 201 });
       } catch (err2) {
         if (err2 instanceof IngestPersistedError) {
           deps.logger?.error?.({
@@ -117684,7 +118155,7 @@ function parseField(value, index) {
     }
     required2 = value.required;
   }
-  const field = { name, type, required: required2 };
+  const field2 = { name, type, required: required2 };
   if (type === "string") {
     let maxLength = MAX_ANSWER_STRING_CHARS;
     if (value.maxLength !== void 0 && value.maxLength !== null) {
@@ -117693,26 +118164,26 @@ function parseField(value, index) {
       }
       maxLength = value.maxLength;
     }
-    field.maxLength = maxLength;
+    field2.maxLength = maxLength;
   }
   if (type === "number" || type === "integer") {
     const integer2 = type === "integer";
     if (value.min !== void 0 && value.min !== null) {
-      field.min = parseBound(value.min, index, "min", integer2);
+      field2.min = parseBound(value.min, index, "min", integer2);
     }
     if (value.max !== void 0 && value.max !== null) {
-      field.max = parseBound(value.max, index, "max", integer2);
+      field2.max = parseBound(value.max, index, "max", integer2);
     }
-    if (field.min !== void 0 && field.max !== void 0 && field.min > field.max) {
+    if (field2.min !== void 0 && field2.max !== void 0 && field2.min > field2.max) {
       invalid(`answerShape.fields[${index}].min is greater than its max`, {
         index
       });
     }
   }
   if (type === "enum") {
-    field.values = parseEnumValues(value.values, index);
+    field2.values = parseEnumValues(value.values, index);
   }
-  return field;
+  return field2;
 }
 function parseAnswerShapeInput(value) {
   if (value === void 0 || value === null)
@@ -117736,30 +118207,30 @@ function parseAnswerShapeInput(value) {
   const fields = [];
   const names = /* @__PURE__ */ new Set();
   value.fields.forEach((entry, index) => {
-    const field = parseField(entry, index);
-    if (names.has(field.name)) {
-      invalid(`answerShape.fields names "${field.name}" twice`, { index });
+    const field2 = parseField(entry, index);
+    if (names.has(field2.name)) {
+      invalid(`answerShape.fields names "${field2.name}" twice`, { index });
     }
-    names.add(field.name);
-    fields.push(field);
+    names.add(field2.name);
+    fields.push(field2);
   });
   return { fields };
 }
 function compileAnswerShape(shape) {
   const entries = {};
-  for (const field of shape.fields) {
+  for (const field2 of shape.fields) {
     let schema;
-    switch (field.type) {
+    switch (field2.type) {
       case "string":
-        schema = external_exports.string().max(field.maxLength ?? MAX_ANSWER_STRING_CHARS);
+        schema = external_exports.string().max(field2.maxLength ?? MAX_ANSWER_STRING_CHARS);
         break;
       case "number":
       case "integer": {
-        let numeric = field.type === "integer" ? external_exports.int() : external_exports.number();
-        if (field.min !== void 0)
-          numeric = numeric.min(field.min);
-        if (field.max !== void 0)
-          numeric = numeric.max(field.max);
+        let numeric = field2.type === "integer" ? external_exports.int() : external_exports.number();
+        if (field2.min !== void 0)
+          numeric = numeric.min(field2.min);
+        if (field2.max !== void 0)
+          numeric = numeric.max(field2.max);
         schema = numeric;
         break;
       }
@@ -117767,10 +118238,10 @@ function compileAnswerShape(shape) {
         schema = external_exports.boolean();
         break;
       case "enum":
-        schema = external_exports.enum(field.values ?? []);
+        schema = external_exports.enum(field2.values ?? []);
         break;
     }
-    entries[field.name] = field.required ? schema : schema.nullish();
+    entries[field2.name] = field2.required ? schema : schema.nullish();
   }
   return external_exports.object(entries);
 }
@@ -117789,44 +118260,44 @@ function validateAnswerShape(shape, compiled, candidate) {
     };
   }
   const value = {};
-  for (const field of shape.fields) {
-    const entry = parsed.data[field.name];
+  for (const field2 of shape.fields) {
+    const entry = parsed.data[field2.name];
     if (entry === void 0 || entry === null)
       continue;
-    value[field.name] = entry;
+    value[field2.name] = entry;
   }
   return { ok: true, value };
 }
-function describeField(field) {
-  const requirement = field.required ? "required" : "optional";
-  switch (field.type) {
+function describeField(field2) {
+  const requirement = field2.required ? "required" : "optional";
+  switch (field2.type) {
     case "string":
-      return `"${field.name}": string, at most ${field.maxLength ?? MAX_ANSWER_STRING_CHARS} characters (${requirement})`;
+      return `"${field2.name}": string, at most ${field2.maxLength ?? MAX_ANSWER_STRING_CHARS} characters (${requirement})`;
     case "number":
     case "integer": {
-      const kind = field.type === "integer" ? "integer" : "number";
-      const range = field.min !== void 0 && field.max !== void 0 ? ` between ${field.min} and ${field.max}` : field.min !== void 0 ? ` of at least ${field.min}` : field.max !== void 0 ? ` of at most ${field.max}` : "";
-      return `"${field.name}": ${kind}${range} (${requirement})`;
+      const kind = field2.type === "integer" ? "integer" : "number";
+      const range = field2.min !== void 0 && field2.max !== void 0 ? ` between ${field2.min} and ${field2.max}` : field2.min !== void 0 ? ` of at least ${field2.min}` : field2.max !== void 0 ? ` of at most ${field2.max}` : "";
+      return `"${field2.name}": ${kind}${range} (${requirement})`;
     }
     case "boolean":
-      return `"${field.name}": true or false (${requirement})`;
+      return `"${field2.name}": true or false (${requirement})`;
     case "enum":
-      return `"${field.name}": exactly one of ${(field.values ?? []).map((entry) => JSON.stringify(entry)).join(", ")} (${requirement})`;
+      return `"${field2.name}": exactly one of ${(field2.values ?? []).map((entry) => JSON.stringify(entry)).join(", ")} (${requirement})`;
   }
 }
 function describeAnswerShape(shape) {
-  return shape.fields.map((field) => `  ${describeField(field)}`);
+  return shape.fields.map((field2) => `  ${describeField(field2)}`);
 }
 function renderShapedAnswer(shape, value) {
-  return shape.fields.filter((field) => value[field.name] !== void 0).map((field) => `${field.name}: ${String(value[field.name])}`).join("\n");
+  return shape.fields.filter((field2) => value[field2.name] !== void 0).map((field2) => `${field2.name}: ${String(value[field2.name])}`).join("\n");
 }
 function cloneAnswerShape(shape) {
   if (!shape)
     return null;
   return {
-    fields: shape.fields.map((field) => ({
-      ...field,
-      ...field.values ? { values: [...field.values] } : {}
+    fields: shape.fields.map((field2) => ({
+      ...field2,
+      ...field2.values ? { values: [...field2.values] } : {}
     }))
   };
 }
@@ -117933,15 +118404,15 @@ var MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
 function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function parseScope(value, field) {
+function parseScope(value, field2) {
   if (typeof value !== "string") {
-    throw new DerivativeQuestionInvalidError(`${field} must be a scope string`, {
-      field
+    throw new DerivativeQuestionInvalidError(`${field2} must be a scope string`, {
+      field: field2
     });
   }
   const parsed = parseDataScopeContract(value);
   if (!parsed.ok) {
-    throw new DerivativeQuestionInvalidError(`${field} is not a valid scope: ${parsed.body.message}`, { field, scope: value.slice(0, MAX_ECHOED_SCOPE_CHARS) });
+    throw new DerivativeQuestionInvalidError(`${field2} is not a valid scope: ${parsed.body.message}`, { field: field2, scope: value.slice(0, MAX_ECHOED_SCOPE_CHARS) });
   }
   return parsed.scope;
 }
@@ -118318,14 +118789,14 @@ function readContent(body) {
   if (!isRecord7(first) || !isRecord7(first.message))
     return null;
   const index = typeof first.index === "number" ? first.index : 0;
-  const field = `choices.${index}.message.content`;
+  const field2 = `choices.${index}.message.content`;
   const id2 = typeof body.id === "string" ? body.id : "";
   const content = first.message.content;
   if (typeof content === "string")
-    return { content, field, id: id2 };
+    return { content, field: field2, id: id2 };
   if (Array.isArray(content)) {
     const text = content.map((part) => isRecord7(part) && typeof part.text === "string" ? part.text : "").join("");
-    return { content: text, field, id: id2 };
+    return { content: text, field: field2, id: id2 };
   }
   return null;
 }
@@ -118558,7 +119029,7 @@ async function produceAnswer(deps, registration, model, messages) {
       answerShape: shape
     });
   }
-  throw new ComputeFailure(`answer did not match the declared shape (fields: ${shape.fields.map((field) => field.name).join(", ")})`, "internal");
+  throw new ComputeFailure(`answer did not match the declared shape (fields: ${shape.fields.map((field2) => field2.name).join(", ")})`, "internal");
 }
 function collectedAtStamp(now, isTaken) {
   const base = now();
@@ -119379,23 +119850,23 @@ function canonicalJsonBytes(value) {
 // ../core/dist/derivatives/e2ee/aad.js
 var E2EE_REQUEST_AAD_PURPOSE = "aci.e2ee.request.v2";
 var E2EE_RESPONSE_AAD_PURPOSE = "aci.e2ee.response.v2";
-function requestFieldAad(context, field) {
+function requestFieldAad(context, field2) {
   return canonicalJsonBytes({
     purpose: E2EE_REQUEST_AAD_PURPOSE,
     algo: context.algo,
     model: context.model,
-    field,
+    field: field2,
     nonce: context.nonce,
     ts: context.ts
   });
 }
-function responseFieldAad(context, field, id2) {
+function responseFieldAad(context, field2, id2) {
   return canonicalJsonBytes({
     purpose: E2EE_RESPONSE_AAD_PURPOSE,
     algo: context.algo,
     model: context.model,
     id: id2,
-    field,
+    field: field2,
     nonce: context.nonce,
     ts: context.ts
   });
@@ -119815,7 +120286,7 @@ function createPhalaE2eeEncryption(options) {
       }
       const request2 = {
         messages: encrypted,
-        async decryptResponse({ content, field, id: id2, headers: response }) {
+        async decryptResponse({ content, field: field2, id: id2, headers: response }) {
           const served = response.get(ACI_HEADER_KEYSET_DIGEST);
           if (served && served !== gatewayKey.keysetDigest) {
             options.logger?.warn?.({ pinned: gatewayKey.keysetDigest, served }, "E2EE keyset digest changed; refetching the attestation report");
@@ -119825,11 +120296,11 @@ function createPhalaE2eeEncryption(options) {
             return await decryptField({
               wire: content,
               privateKey: client.privateKey,
-              aad: responseFieldAad(context, field, id2)
+              aad: responseFieldAad(context, field2, id2)
             });
           } catch (err2) {
             const detail = err2 instanceof E2eeCipherError ? err2.message : "unexpected error";
-            throw new InferenceRequestError(`e2ee response decryption failed for ${field} (${detail})`, null, { errorType: "e2ee_decryption_failed", retryable: false });
+            throw new InferenceRequestError(`e2ee response decryption failed for ${field2} (${detail})`, null, { errorType: "e2ee_decryption_failed", retryable: false });
           }
         }
       };
@@ -120946,16 +121417,16 @@ var MiniSearch = class _MiniSearch {
     }
     const shortDocumentId = this.addDocumentId(id2);
     this.saveStoredFields(shortDocumentId, document2);
-    for (const field of fields) {
-      const fieldValue = extractField(document2, field);
+    for (const field2 of fields) {
+      const fieldValue = extractField(document2, field2);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(stringifyField(fieldValue, field), field);
-      const fieldId = this._fieldIds[field];
+      const tokens = tokenize(stringifyField(fieldValue, field2), field2);
+      const fieldId = this._fieldIds[field2];
       const uniqueTerms = new Set(tokens).size;
       this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
       for (const term of tokens) {
-        const processedTerm = processTerm2(term, field);
+        const processedTerm = processTerm2(term, field2);
         if (Array.isArray(processedTerm)) {
           for (const t10 of processedTerm) {
             this.addTerm(fieldId, shortDocumentId, t10);
@@ -121026,16 +121497,16 @@ var MiniSearch = class _MiniSearch {
     if (shortId == null) {
       throw new Error(`MiniSearch: cannot remove document with ID ${id2}: it is not in the index`);
     }
-    for (const field of fields) {
-      const fieldValue = extractField(document2, field);
+    for (const field2 of fields) {
+      const fieldValue = extractField(document2, field2);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(stringifyField(fieldValue, field), field);
-      const fieldId = this._fieldIds[field];
+      const tokens = tokenize(stringifyField(fieldValue, field2), field2);
+      const fieldId = this._fieldIds[field2];
       const uniqueTerms = new Set(tokens).size;
       this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
       for (const term of tokens) {
-        const processedTerm = processTerm2(term, field);
+        const processedTerm = processTerm2(term, field2);
         if (Array.isArray(processedTerm)) {
           for (const t10 of processedTerm) {
             this.removeTerm(fieldId, shortId, t10);
@@ -121785,7 +122256,7 @@ var MiniSearch = class _MiniSearch {
    */
   executeQuerySpec(query, searchOptions) {
     const options = { ...this._options.searchOptions, ...searchOptions };
-    const boosts = (options.fields || this._options.fields).reduce((boosts2, field) => ({ ...boosts2, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+    const boosts = (options.fields || this._options.fields).reduce((boosts2, field2) => ({ ...boosts2, [field2]: getOwnProperty(options.boost, field2) || 1 }), {});
     const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
     const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
     const data = this._index.get(query.term);
@@ -121906,9 +122377,9 @@ var MiniSearch = class _MiniSearch {
   termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = /* @__PURE__ */ new Map()) {
     if (fieldTermData == null)
       return results;
-    for (const field of Object.keys(fieldBoosts)) {
-      const fieldBoost = fieldBoosts[field];
-      const fieldId = this._fieldIds[field];
+    for (const field2 of Object.keys(fieldBoosts)) {
+      const fieldBoost = fieldBoosts[field2];
+      const fieldId = this._fieldIds[field2];
       const fieldTermFreqs = fieldTermData.get(fieldId);
       if (fieldTermFreqs == null)
         continue;
@@ -121933,15 +122404,15 @@ var MiniSearch = class _MiniSearch {
           assignUniqueTerm(result.terms, sourceTerm);
           const match = getOwnProperty(result.match, derivedTerm);
           if (match) {
-            match.push(field);
+            match.push(field2);
           } else {
-            result.match[derivedTerm] = [field];
+            result.match[derivedTerm] = [field2];
           }
         } else {
           results.set(docId, {
             score: weightedScore,
             terms: [sourceTerm],
-            match: { [derivedTerm]: [field] }
+            match: { [derivedTerm]: [field2] }
           });
         }
       }
@@ -132709,11 +133180,11 @@ var McpServer = class {
       return EMPTY_COMPLETION_RESULT;
     }
     const promptShape = getObjectShape(prompt.argsSchema);
-    const field = promptShape?.[request2.params.argument.name];
-    if (!isCompletable(field)) {
+    const field2 = promptShape?.[request2.params.argument.name];
+    if (!isCompletable(field2)) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const completer = getCompleter(field);
+    const completer = getCompleter(field2);
     if (!completer) {
       return EMPTY_COMPLETION_RESULT;
     }
@@ -132986,8 +133457,8 @@ var McpServer = class {
     };
     this._registeredPrompts[name] = registeredPrompt;
     if (argsSchema) {
-      const hasCompletable = Object.values(argsSchema).some((field) => {
-        const inner = field instanceof ZodOptional ? field._def?.innerType : field;
+      const hasCompletable = Object.values(argsSchema).some((field2) => {
+        const inner = field2 instanceof ZodOptional ? field2._def?.innerType : field2;
         return isCompletable(inner);
       });
       if (hasCompletable) {
@@ -133220,9 +133691,9 @@ function promptArgumentsFromSchema(schema) {
   const shape = getObjectShape(schema);
   if (!shape)
     return [];
-  return Object.entries(shape).map(([name, field]) => {
-    const description = getSchemaDescription(field);
-    const isOptional = isSchemaOptional(field);
+  return Object.entries(shape).map(([name, field2]) => {
+    const description = getSchemaDescription(field2);
+    const isOptional = isSchemaOptional(field2);
     return {
       name,
       description,