windows-development-sandbox 1.7.0 → 1.9.0

package/dist/runtime/daemon.js

@@ -18,9 +18,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -501,9 +501,9 @@ var require_lodash = __commonJS({
       }
       function baseFindKey(collection, predicate, eachFunc) {
         var result;
-        eachFunc(collection, function(value, key, collection2) {
-          if (predicate(value, key, collection2)) {
-            result = key;
+        eachFunc(collection, function(value, key2, collection2) {
+          if (predicate(value, key2, collection2)) {
+            result = key2;
             return false;
           }
         });
@@ -537,14 +537,14 @@ var require_lodash = __commonJS({
         var length = array2 == null ? 0 : array2.length;
         return length ? baseSum(array2, iteratee) / length : NAN;
       }
-      function baseProperty(key) {
+      function baseProperty(key2) {
         return function(object2) {
-          return object2 == null ? undefined2 : object2[key];
+          return object2 == null ? undefined2 : object2[key2];
         };
       }
       function basePropertyOf(object2) {
-        return function(key) {
-          return object2 == null ? undefined2 : object2[key];
+        return function(key2) {
+          return object2 == null ? undefined2 : object2[key2];
         };
       }
       function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
@@ -579,8 +579,8 @@ var require_lodash = __commonJS({
         return result;
       }
       function baseToPairs(object2, props) {
-        return arrayMap(props, function(key) {
-          return [key, object2[key]];
+        return arrayMap(props, function(key2) {
+          return [key2, object2[key2]];
         });
       }
       function baseTrim(string4) {
@@ -592,12 +592,12 @@ var require_lodash = __commonJS({
         };
       }
       function baseValues(object2, props) {
-        return arrayMap(props, function(key) {
-          return object2[key];
+        return arrayMap(props, function(key2) {
+          return object2[key2];
         });
       }
-      function cacheHas(cache, key) {
-        return cache.has(key);
+      function cacheHas(cache, key2) {
+        return cache.has(key2);
       }
       function charsStartIndex(strSymbols, chrSymbols) {
         var index = -1, length = strSymbols.length;
@@ -625,8 +625,8 @@ var require_lodash = __commonJS({
       function escapeStringChar(chr) {
         return "\\" + stringEscapes[chr];
       }
-      function getValue(object2, key) {
-        return object2 == null ? undefined2 : object2[key];
+      function getValue(object2, key2) {
+        return object2 == null ? undefined2 : object2[key2];
       }
       function hasUnicode(string4) {
         return reHasUnicode.test(string4);
@@ -643,8 +643,8 @@ var require_lodash = __commonJS({
       }
       function mapToArray(map2) {
         var index = -1, result = Array(map2.size);
-        map2.forEach(function(value, key) {
-          result[++index] = [key, value];
+        map2.forEach(function(value, key2) {
+          result[++index] = [key2, value];
         });
         return result;
       }
@@ -911,27 +911,27 @@ var require_lodash = __commonJS({
           this.__data__ = nativeCreate ? nativeCreate(null) : {};
           this.size = 0;
         }
-        function hashDelete(key) {
-          var result2 = this.has(key) && delete this.__data__[key];
+        function hashDelete(key2) {
+          var result2 = this.has(key2) && delete this.__data__[key2];
           this.size -= result2 ? 1 : 0;
           return result2;
         }
-        function hashGet(key) {
+        function hashGet(key2) {
           var data = this.__data__;
           if (nativeCreate) {
-            var result2 = data[key];
+            var result2 = data[key2];
             return result2 === HASH_UNDEFINED ? undefined2 : result2;
           }
-          return hasOwnProperty.call(data, key) ? data[key] : undefined2;
+          return hasOwnProperty.call(data, key2) ? data[key2] : undefined2;
         }
-        function hashHas(key) {
+        function hashHas(key2) {
           var data = this.__data__;
-          return nativeCreate ? data[key] !== undefined2 : hasOwnProperty.call(data, key);
+          return nativeCreate ? data[key2] !== undefined2 : hasOwnProperty.call(data, key2);
         }
-        function hashSet(key, value) {
+        function hashSet(key2, value) {
           var data = this.__data__;
-          this.size += this.has(key) ? 0 : 1;
-          data[key] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value;
+          this.size += this.has(key2) ? 0 : 1;
+          data[key2] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value;
           return this;
         }
         Hash.prototype.clear = hashClear;
@@ -951,8 +951,8 @@ var require_lodash = __commonJS({
           this.__data__ = [];
           this.size = 0;
         }
-        function listCacheDelete(key) {
-          var data = this.__data__, index = assocIndexOf(data, key);
+        function listCacheDelete(key2) {
+          var data = this.__data__, index = assocIndexOf(data, key2);
           if (index < 0) {
             return false;
           }
@@ -965,18 +965,18 @@ var require_lodash = __commonJS({
           --this.size;
           return true;
         }
-        function listCacheGet(key) {
-          var data = this.__data__, index = assocIndexOf(data, key);
+        function listCacheGet(key2) {
+          var data = this.__data__, index = assocIndexOf(data, key2);
           return index < 0 ? undefined2 : data[index][1];
         }
-        function listCacheHas(key) {
-          return assocIndexOf(this.__data__, key) > -1;
+        function listCacheHas(key2) {
+          return assocIndexOf(this.__data__, key2) > -1;
         }
-        function listCacheSet(key, value) {
-          var data = this.__data__, index = assocIndexOf(data, key);
+        function listCacheSet(key2, value) {
+          var data = this.__data__, index = assocIndexOf(data, key2);
           if (index < 0) {
             ++this.size;
-            data.push([key, value]);
+            data.push([key2, value]);
           } else {
             data[index][1] = value;
           }
@@ -1003,20 +1003,20 @@ var require_lodash = __commonJS({
             "string": new Hash()
           };
         }
-        function mapCacheDelete(key) {
-          var result2 = getMapData(this, key)["delete"](key);
+        function mapCacheDelete(key2) {
+          var result2 = getMapData(this, key2)["delete"](key2);
           this.size -= result2 ? 1 : 0;
           return result2;
         }
-        function mapCacheGet(key) {
-          return getMapData(this, key).get(key);
+        function mapCacheGet(key2) {
+          return getMapData(this, key2).get(key2);
         }
-        function mapCacheHas(key) {
-          return getMapData(this, key).has(key);
+        function mapCacheHas(key2) {
+          return getMapData(this, key2).has(key2);
         }
-        function mapCacheSet(key, value) {
-          var data = getMapData(this, key), size2 = data.size;
-          data.set(key, value);
+        function mapCacheSet(key2, value) {
+          var data = getMapData(this, key2), size2 = data.size;
+          data.set(key2, value);
           this.size += data.size == size2 ? 0 : 1;
           return this;
         }
@@ -1049,29 +1049,29 @@ var require_lodash = __commonJS({
           this.__data__ = new ListCache();
           this.size = 0;
         }
-        function stackDelete(key) {
-          var data = this.__data__, result2 = data["delete"](key);
+        function stackDelete(key2) {
+          var data = this.__data__, result2 = data["delete"](key2);
           this.size = data.size;
           return result2;
         }
-        function stackGet(key) {
-          return this.__data__.get(key);
+        function stackGet(key2) {
+          return this.__data__.get(key2);
         }
-        function stackHas(key) {
-          return this.__data__.has(key);
+        function stackHas(key2) {
+          return this.__data__.has(key2);
         }
-        function stackSet(key, value) {
+        function stackSet(key2, value) {
           var data = this.__data__;
           if (data instanceof ListCache) {
             var pairs = data.__data__;
             if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
-              pairs.push([key, value]);
+              pairs.push([key2, value]);
               this.size = ++data.size;
               return this;
             }
             data = this.__data__ = new MapCache(pairs);
           }
-          data.set(key, value);
+          data.set(key2, value);
           this.size = data.size;
           return this;
         }
@@ -1082,13 +1082,13 @@ var require_lodash = __commonJS({
         Stack.prototype.set = stackSet;
         function arrayLikeKeys(value, inherited) {
           var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length;
-          for (var key in value) {
-            if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
-            (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
-            isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
-            isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
-            isIndex(key, length)))) {
-              result2.push(key);
+          for (var key2 in value) {
+            if ((inherited || hasOwnProperty.call(value, key2)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+            (key2 == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+            isBuff && (key2 == "offset" || key2 == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+            isType && (key2 == "buffer" || key2 == "byteLength" || key2 == "byteOffset") || // Skip index properties.
+            isIndex(key2, length)))) {
+              result2.push(key2);
             }
           }
           return result2;
@@ -1103,28 +1103,28 @@ var require_lodash = __commonJS({
         function arrayShuffle(array2) {
           return shuffleSelf(copyArray(array2));
         }
-        function assignMergeValue(object2, key, value) {
-          if (value !== undefined2 && !eq(object2[key], value) || value === undefined2 && !(key in object2)) {
-            baseAssignValue(object2, key, value);
+        function assignMergeValue(object2, key2, value) {
+          if (value !== undefined2 && !eq(object2[key2], value) || value === undefined2 && !(key2 in object2)) {
+            baseAssignValue(object2, key2, value);
           }
         }
-        function assignValue(object2, key, value) {
-          var objValue = object2[key];
-          if (!(hasOwnProperty.call(object2, key) && eq(objValue, value)) || value === undefined2 && !(key in object2)) {
-            baseAssignValue(object2, key, value);
+        function assignValue(object2, key2, value) {
+          var objValue = object2[key2];
+          if (!(hasOwnProperty.call(object2, key2) && eq(objValue, value)) || value === undefined2 && !(key2 in object2)) {
+            baseAssignValue(object2, key2, value);
           }
         }
-        function assocIndexOf(array2, key) {
+        function assocIndexOf(array2, key2) {
           var length = array2.length;
           while (length--) {
-            if (eq(array2[length][0], key)) {
+            if (eq(array2[length][0], key2)) {
               return length;
             }
           }
           return -1;
         }
         function baseAggregator(collection, setter, iteratee2, accumulator) {
-          baseEach(collection, function(value, key, collection2) {
+          baseEach(collection, function(value, key2, collection2) {
             setter(accumulator, value, iteratee2(value), collection2);
           });
           return accumulator;
@@ -1135,16 +1135,16 @@ var require_lodash = __commonJS({
         function baseAssignIn(object2, source) {
           return object2 && copyObject(source, keysIn(source), object2);
         }
-        function baseAssignValue(object2, key, value) {
-          if (key == "__proto__" && defineProperty) {
-            defineProperty(object2, key, {
+        function baseAssignValue(object2, key2, value) {
+          if (key2 == "__proto__" && defineProperty) {
+            defineProperty(object2, key2, {
               "configurable": true,
               "enumerable": true,
               "value": value,
               "writable": true
             });
           } else {
-            object2[key] = value;
+            object2[key2] = value;
           }
         }
         function baseAt(object2, paths) {
@@ -1165,10 +1165,10 @@ var require_lodash = __commonJS({
           }
           return number4;
         }
-        function baseClone(value, bitmask, customizer, key, object2, stack) {
+        function baseClone(value, bitmask, customizer, key2, object2, stack) {
           var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
           if (customizer) {
-            result2 = object2 ? customizer(value, key, object2, stack) : customizer(value);
+            result2 = object2 ? customizer(value, key2, object2, stack) : customizer(value);
           }
           if (result2 !== undefined2) {
             return result2;
@@ -1210,18 +1210,18 @@ var require_lodash = __commonJS({
               result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
             });
           } else if (isMap(value)) {
-            value.forEach(function(subValue, key2) {
-              result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+            value.forEach(function(subValue, key3) {
+              result2.set(key3, baseClone(subValue, bitmask, customizer, key3, value, stack));
             });
           }
           var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
           var props = isArr ? undefined2 : keysFunc(value);
-          arrayEach(props || value, function(subValue, key2) {
+          arrayEach(props || value, function(subValue, key3) {
             if (props) {
-              key2 = subValue;
-              subValue = value[key2];
+              key3 = subValue;
+              subValue = value[key3];
             }
-            assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+            assignValue(result2, key3, baseClone(subValue, bitmask, customizer, key3, value, stack));
           });
           return result2;
         }
@@ -1238,8 +1238,8 @@ var require_lodash = __commonJS({
           }
           object2 = Object2(object2);
           while (length--) {
-            var key = props[length], predicate = source[key], value = object2[key];
-            if (value === undefined2 && !(key in object2) || !predicate(value)) {
+            var key2 = props[length], predicate = source[key2], value = object2[key2];
+            if (value === undefined2 && !(key2 in object2) || !predicate(value)) {
               return false;
             }
           }
@@ -1359,15 +1359,15 @@ var require_lodash = __commonJS({
           return object2 && baseForRight(object2, iteratee2, keys);
         }
         function baseFunctions(object2, props) {
-          return arrayFilter(props, function(key) {
-            return isFunction(object2[key]);
+          return arrayFilter(props, function(key2) {
+            return isFunction(object2[key2]);
           });
         }
-        function baseGet(object2, path68) {
-          path68 = castPath(path68, object2);
-          var index = 0, length = path68.length;
+        function baseGet(object2, path69) {
+          path69 = castPath(path69, object2);
+          var index = 0, length = path69.length;
           while (object2 != null && index < length) {
-            object2 = object2[toKey(path68[index++])];
+            object2 = object2[toKey(path69[index++])];
           }
           return index && index == length ? object2 : undefined2;
         }
@@ -1384,11 +1384,11 @@ var require_lodash = __commonJS({
         function baseGt(value, other) {
           return value > other;
         }
-        function baseHas(object2, key) {
-          return object2 != null && hasOwnProperty.call(object2, key);
+        function baseHas(object2, key2) {
+          return object2 != null && hasOwnProperty.call(object2, key2);
         }
-        function baseHasIn(object2, key) {
-          return object2 != null && key in Object2(object2);
+        function baseHasIn(object2, key2) {
+          return object2 != null && key2 in Object2(object2);
         }
         function baseInRange(number4, start, end) {
           return number4 >= nativeMin(start, end) && number4 < nativeMax(start, end);
@@ -1426,15 +1426,15 @@ var require_lodash = __commonJS({
           return result2;
         }
         function baseInverter(object2, setter, iteratee2, accumulator) {
-          baseForOwn(object2, function(value, key, object3) {
-            setter(accumulator, iteratee2(value), key, object3);
+          baseForOwn(object2, function(value, key2, object3) {
+            setter(accumulator, iteratee2(value), key2, object3);
           });
           return accumulator;
         }
-        function baseInvoke(object2, path68, args) {
-          path68 = castPath(path68, object2);
-          object2 = parent(object2, path68);
-          var func = object2 == null ? object2 : object2[toKey(last(path68))];
+        function baseInvoke(object2, path69, args) {
+          path69 = castPath(path69, object2);
+          object2 = parent(object2, path69);
+          var func = object2 == null ? object2 : object2[toKey(last(path69))];
           return func == null ? undefined2 : apply(func, object2, args);
         }
         function baseIsArguments(value) {
@@ -1502,15 +1502,15 @@ var require_lodash = __commonJS({
           }
           while (++index < length) {
             data = matchData[index];
-            var key = data[0], objValue = object2[key], srcValue = data[1];
+            var key2 = data[0], objValue = object2[key2], srcValue = data[1];
             if (noCustomizer && data[2]) {
-              if (objValue === undefined2 && !(key in object2)) {
+              if (objValue === undefined2 && !(key2 in object2)) {
                 return false;
               }
             } else {
               var stack = new Stack();
               if (customizer) {
-                var result2 = customizer(objValue, srcValue, key, object2, source, stack);
+                var result2 = customizer(objValue, srcValue, key2, object2, source, stack);
               }
               if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {
                 return false;
@@ -1552,9 +1552,9 @@ var require_lodash = __commonJS({
             return nativeKeys(object2);
           }
           var result2 = [];
-          for (var key in Object2(object2)) {
-            if (hasOwnProperty.call(object2, key) && key != "constructor") {
-              result2.push(key);
+          for (var key2 in Object2(object2)) {
+            if (hasOwnProperty.call(object2, key2) && key2 != "constructor") {
+              result2.push(key2);
             }
           }
           return result2;
@@ -1564,9 +1564,9 @@ var require_lodash = __commonJS({
             return nativeKeysIn(object2);
           }
           var isProto = isPrototype(object2), result2 = [];
-          for (var key in object2) {
-            if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object2, key)))) {
-              result2.push(key);
+          for (var key2 in object2) {
+            if (!(key2 == "constructor" && (isProto || !hasOwnProperty.call(object2, key2)))) {
+              result2.push(key2);
             }
           }
           return result2;
@@ -1576,8 +1576,8 @@ var require_lodash = __commonJS({
         }
         function baseMap(collection, iteratee2) {
           var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];
-          baseEach(collection, function(value, key, collection2) {
-            result2[++index] = iteratee2(value, key, collection2);
+          baseEach(collection, function(value, key2, collection2) {
+            result2[++index] = iteratee2(value, key2, collection2);
           });
           return result2;
         }
@@ -1590,39 +1590,39 @@ var require_lodash = __commonJS({
             return object2 === source || baseIsMatch(object2, source, matchData);
           };
         }
-        function baseMatchesProperty(path68, srcValue) {
-          if (isKey(path68) && isStrictComparable(srcValue)) {
-            return matchesStrictComparable(toKey(path68), srcValue);
+        function baseMatchesProperty(path69, srcValue) {
+          if (isKey(path69) && isStrictComparable(srcValue)) {
+            return matchesStrictComparable(toKey(path69), srcValue);
           }
           return function(object2) {
-            var objValue = get(object2, path68);
-            return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path68) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+            var objValue = get(object2, path69);
+            return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path69) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
           };
         }
         function baseMerge(object2, source, srcIndex, customizer, stack) {
           if (object2 === source) {
             return;
           }
-          baseFor(source, function(srcValue, key) {
+          baseFor(source, function(srcValue, key2) {
             stack || (stack = new Stack());
             if (isObject2(srcValue)) {
-              baseMergeDeep(object2, source, key, srcIndex, baseMerge, customizer, stack);
+              baseMergeDeep(object2, source, key2, srcIndex, baseMerge, customizer, stack);
             } else {
-              var newValue = customizer ? customizer(safeGet(object2, key), srcValue, key + "", object2, source, stack) : undefined2;
+              var newValue = customizer ? customizer(safeGet(object2, key2), srcValue, key2 + "", object2, source, stack) : undefined2;
               if (newValue === undefined2) {
                 newValue = srcValue;
               }
-              assignMergeValue(object2, key, newValue);
+              assignMergeValue(object2, key2, newValue);
             }
           }, keysIn);
         }
-        function baseMergeDeep(object2, source, key, srcIndex, mergeFunc, customizer, stack) {
-          var objValue = safeGet(object2, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
+        function baseMergeDeep(object2, source, key2, srcIndex, mergeFunc, customizer, stack) {
+          var objValue = safeGet(object2, key2), srcValue = safeGet(source, key2), stacked = stack.get(srcValue);
           if (stacked) {
-            assignMergeValue(object2, key, stacked);
+            assignMergeValue(object2, key2, stacked);
             return;
           }
-          var newValue = customizer ? customizer(objValue, srcValue, key + "", object2, source, stack) : undefined2;
+          var newValue = customizer ? customizer(objValue, srcValue, key2 + "", object2, source, stack) : undefined2;
           var isCommon = newValue === undefined2;
           if (isCommon) {
             var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
@@ -1657,7 +1657,7 @@ var require_lodash = __commonJS({
             mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
             stack["delete"](srcValue);
           }
-          assignMergeValue(object2, key, newValue);
+          assignMergeValue(object2, key2, newValue);
         }
         function baseNth(array2, n) {
           var length = array2.length;
@@ -1682,7 +1682,7 @@ var require_lodash = __commonJS({
           }
           var index = -1;
           iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
-          var result2 = baseMap(collection, function(value, key, collection2) {
+          var result2 = baseMap(collection, function(value, key2, collection2) {
             var criteria = arrayMap(iteratees, function(iteratee2) {
               return iteratee2(value);
             });
@@ -1693,23 +1693,23 @@ var require_lodash = __commonJS({
           });
         }
         function basePick(object2, paths) {
-          return basePickBy(object2, paths, function(value, path68) {
-            return hasIn(object2, path68);
+          return basePickBy(object2, paths, function(value, path69) {
+            return hasIn(object2, path69);
           });
         }
         function basePickBy(object2, paths, predicate) {
           var index = -1, length = paths.length, result2 = {};
           while (++index < length) {
-            var path68 = paths[index], value = baseGet(object2, path68);
-            if (predicate(value, path68)) {
-              baseSet(result2, castPath(path68, object2), value);
+            var path69 = paths[index], value = baseGet(object2, path69);
+            if (predicate(value, path69)) {
+              baseSet(result2, castPath(path69, object2), value);
             }
           }
           return result2;
         }
-        function basePropertyDeep(path68) {
+        function basePropertyDeep(path69) {
           return function(object2) {
-            return baseGet(object2, path68);
+            return baseGet(object2, path69);
           };
         }
         function basePullAll(array2, values2, iteratee2, comparator) {
@@ -1783,26 +1783,26 @@ var require_lodash = __commonJS({
           var array2 = values(collection);
           return shuffleSelf(array2, baseClamp(n, 0, array2.length));
         }
-        function baseSet(object2, path68, value, customizer) {
+        function baseSet(object2, path69, value, customizer) {
           if (!isObject2(object2)) {
             return object2;
           }
-          path68 = castPath(path68, object2);
-          var index = -1, length = path68.length, lastIndex = length - 1, nested = object2;
+          path69 = castPath(path69, object2);
+          var index = -1, length = path69.length, lastIndex = length - 1, nested = object2;
           while (nested != null && ++index < length) {
-            var key = toKey(path68[index]), newValue = value;
-            if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            var key2 = toKey(path69[index]), newValue = value;
+            if (key2 === "__proto__" || key2 === "constructor" || key2 === "prototype") {
               return object2;
             }
             if (index != lastIndex) {
-              var objValue = nested[key];
-              newValue = customizer ? customizer(objValue, key, nested) : undefined2;
+              var objValue = nested[key2];
+              newValue = customizer ? customizer(objValue, key2, nested) : undefined2;
               if (newValue === undefined2) {
-                newValue = isObject2(objValue) ? objValue : isIndex(path68[index + 1]) ? [] : {};
+                newValue = isObject2(objValue) ? objValue : isIndex(path69[index + 1]) ? [] : {};
               }
             }
-            assignValue(nested, key, newValue);
-            nested = nested[key];
+            assignValue(nested, key2, newValue);
+            nested = nested[key2];
           }
           return object2;
         }
@@ -1964,26 +1964,26 @@ var require_lodash = __commonJS({
             }
           return result2;
         }
-        function baseUnset(object2, path68) {
-          path68 = castPath(path68, object2);
-          var index = -1, length = path68.length;
+        function baseUnset(object2, path69) {
+          path69 = castPath(path69, object2);
+          var index = -1, length = path69.length;
           if (!length) {
             return true;
           }
           while (++index < length) {
-            var key = toKey(path68[index]);
-            if (key === "__proto__" && !hasOwnProperty.call(object2, "__proto__")) {
+            var key2 = toKey(path69[index]);
+            if (key2 === "__proto__" && !hasOwnProperty.call(object2, "__proto__")) {
               return false;
             }
-            if ((key === "constructor" || key === "prototype") && index < length - 1) {
+            if ((key2 === "constructor" || key2 === "prototype") && index < length - 1) {
               return false;
             }
           }
-          var obj = parent(object2, path68);
-          return obj == null || delete obj[toKey(last(path68))];
+          var obj = parent(object2, path69);
+          return obj == null || delete obj[toKey(last(path69))];
         }
-        function baseUpdate(object2, path68, updater, customizer) {
-          return baseSet(object2, path68, updater(baseGet(object2, path68)), customizer);
+        function baseUpdate(object2, path69, updater, customizer) {
+          return baseSet(object2, path69, updater(baseGet(object2, path69)), customizer);
         }
         function baseWhile(array2, predicate, isDrop, fromRight) {
           var length = array2.length, index = fromRight ? length : -1;
@@ -2145,15 +2145,15 @@ var require_lodash = __commonJS({
           object2 || (object2 = {});
           var index = -1, length = props.length;
           while (++index < length) {
-            var key = props[index];
-            var newValue = customizer ? customizer(object2[key], source[key], key, object2, source) : undefined2;
+            var key2 = props[index];
+            var newValue = customizer ? customizer(object2[key2], source[key2], key2, object2, source) : undefined2;
             if (newValue === undefined2) {
-              newValue = source[key];
+              newValue = source[key2];
             }
             if (isNew) {
-              baseAssignValue(object2, key, newValue);
+              baseAssignValue(object2, key2, newValue);
             } else {
-              assignValue(object2, key, newValue);
+              assignValue(object2, key2, newValue);
             }
           }
           return object2;
@@ -2209,8 +2209,8 @@ var require_lodash = __commonJS({
           return function(object2, iteratee2, keysFunc) {
             var index = -1, iterable = Object2(object2), props = keysFunc(object2), length = props.length;
             while (length--) {
-              var key = props[fromRight ? length : ++index];
-              if (iteratee2(iterable[key], key, iterable) === false) {
+              var key2 = props[fromRight ? length : ++index];
+              if (iteratee2(iterable[key2], key2, iterable) === false) {
                 break;
               }
             }
@@ -2298,8 +2298,8 @@ var require_lodash = __commonJS({
             if (!isArrayLike(collection)) {
               var iteratee2 = getIteratee(predicate, 3);
               collection = keys(collection);
-              predicate = function(key) {
-                return iteratee2(iterable[key], key, iterable);
+              predicate = function(key2) {
+                return iteratee2(iterable[key2], key2, iterable);
               };
             }
             var index = findIndexFunc(collection, predicate, fromIndex);
@@ -2590,13 +2590,13 @@ var require_lodash = __commonJS({
           var setter = data ? baseSetData : setData;
           return setWrapToString(setter(result2, newData), func, bitmask);
         }
-        function customDefaultsAssignIn(objValue, srcValue, key, object2) {
-          if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object2, key)) {
+        function customDefaultsAssignIn(objValue, srcValue, key2, object2) {
+          if (objValue === undefined2 || eq(objValue, objectProto[key2]) && !hasOwnProperty.call(object2, key2)) {
             return srcValue;
           }
           return objValue;
         }
-        function customDefaultsMerge(objValue, srcValue, key, object2, source, stack) {
+        function customDefaultsMerge(objValue, srcValue, key2, object2, source, stack) {
           if (isObject2(objValue) && isObject2(srcValue)) {
             stack.set(srcValue, objValue);
             baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);
@@ -2703,8 +2703,8 @@ var require_lodash = __commonJS({
           }
           var index = objLength;
           while (index--) {
-            var key = objProps[index];
-            if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+            var key2 = objProps[index];
+            if (!(isPartial ? key2 in other : hasOwnProperty.call(other, key2))) {
               return false;
             }
           }
@@ -2718,16 +2718,16 @@ var require_lodash = __commonJS({
           stack.set(other, object2);
           var skipCtor = isPartial;
           while (++index < objLength) {
-            key = objProps[index];
-            var objValue = object2[key], othValue = other[key];
+            key2 = objProps[index];
+            var objValue = object2[key2], othValue = other[key2];
             if (customizer) {
-              var compared = isPartial ? customizer(othValue, objValue, key, other, object2, stack) : customizer(objValue, othValue, key, object2, other, stack);
+              var compared = isPartial ? customizer(othValue, objValue, key2, other, object2, stack) : customizer(objValue, othValue, key2, object2, other, stack);
             }
             if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
               result2 = false;
               break;
             }
-            skipCtor || (skipCtor = key == "constructor");
+            skipCtor || (skipCtor = key2 == "constructor");
           }
           if (result2 && !skipCtor) {
             var objCtor = object2.constructor, othCtor = other.constructor;
@@ -2770,20 +2770,20 @@ var require_lodash = __commonJS({
           result2 = result2 === iteratee ? baseIteratee : result2;
           return arguments.length ? result2(arguments[0], arguments[1]) : result2;
         }
-        function getMapData(map3, key) {
+        function getMapData(map3, key2) {
           var data = map3.__data__;
-          return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+          return isKeyable(key2) ? data[typeof key2 == "string" ? "string" : "hash"] : data.map;
         }
         function getMatchData(object2) {
           var result2 = keys(object2), length = result2.length;
           while (length--) {
-            var key = result2[length], value = object2[key];
-            result2[length] = [key, value, isStrictComparable(value)];
+            var key2 = result2[length], value = object2[key2];
+            result2[length] = [key2, value, isStrictComparable(value)];
           }
           return result2;
         }
-        function getNative(object2, key) {
-          var value = getValue(object2, key);
+        function getNative(object2, key2) {
+          var value = getValue(object2, key2);
           return baseIsNative(value) ? value : undefined2;
         }
         function getRawTag(value) {
@@ -2866,21 +2866,21 @@ var require_lodash = __commonJS({
           var match = source.match(reWrapDetails);
           return match ? match[1].split(reSplitDetails) : [];
         }
-        function hasPath(object2, path68, hasFunc) {
-          path68 = castPath(path68, object2);
-          var index = -1, length = path68.length, result2 = false;
+        function hasPath(object2, path69, hasFunc) {
+          path69 = castPath(path69, object2);
+          var index = -1, length = path69.length, result2 = false;
           while (++index < length) {
-            var key = toKey(path68[index]);
-            if (!(result2 = object2 != null && hasFunc(object2, key))) {
+            var key2 = toKey(path69[index]);
+            if (!(result2 = object2 != null && hasFunc(object2, key2))) {
               break;
             }
-            object2 = object2[key];
+            object2 = object2[key2];
           }
           if (result2 || ++index != length) {
             return result2;
           }
           length = object2 == null ? 0 : object2.length;
-          return !!length && isLength(length) && isIndex(key, length) && (isArray(object2) || isArguments(object2));
+          return !!length && isLength(length) && isIndex(key2, length) && (isArray(object2) || isArguments(object2));
         }
         function initCloneArray(array2) {
           var length = array2.length, result2 = new array2.constructor(length);
@@ -2990,20 +2990,20 @@ var require_lodash = __commonJS({
         function isStrictComparable(value) {
           return value === value && !isObject2(value);
         }
-        function matchesStrictComparable(key, srcValue) {
+        function matchesStrictComparable(key2, srcValue) {
           return function(object2) {
             if (object2 == null) {
               return false;
             }
-            return object2[key] === srcValue && (srcValue !== undefined2 || key in Object2(object2));
+            return object2[key2] === srcValue && (srcValue !== undefined2 || key2 in Object2(object2));
           };
         }
         function memoizeCapped(func) {
-          var result2 = memoize(func, function(key) {
+          var result2 = memoize(func, function(key2) {
             if (cache.size === MAX_MEMOIZE_SIZE) {
               cache.clear();
             }
-            return key;
+            return key2;
           });
           var cache = result2.cache;
           return result2;
@@ -3047,8 +3047,8 @@ var require_lodash = __commonJS({
         function nativeKeysIn(object2) {
           var result2 = [];
           if (object2 != null) {
-            for (var key in Object2(object2)) {
-              result2.push(key);
+            for (var key2 in Object2(object2)) {
+              result2.push(key2);
             }
           }
           return result2;
@@ -3072,8 +3072,8 @@ var require_lodash = __commonJS({
             return apply(func, this, otherArgs);
           };
         }
-        function parent(object2, path68) {
-          return path68.length < 2 ? object2 : baseGet(object2, baseSlice(path68, 0, -1));
+        function parent(object2, path69) {
+          return path69.length < 2 ? object2 : baseGet(object2, baseSlice(path69, 0, -1));
         }
         function reorder(array2, indexes) {
           var arrLength = array2.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array2);
@@ -3083,14 +3083,14 @@ var require_lodash = __commonJS({
           }
           return array2;
         }
-        function safeGet(object2, key) {
-          if (key === "constructor" && typeof object2[key] === "function") {
+        function safeGet(object2, key2) {
+          if (key2 === "constructor" && typeof object2[key2] === "function") {
             return;
           }
-          if (key == "__proto__") {
+          if (key2 == "__proto__") {
             return;
           }
-          return object2[key];
+          return object2[key2];
         }
         var setData = shortOut(baseSetData);
         var setTimeout2 = ctxSetTimeout || function(func, wait) {
@@ -3654,11 +3654,11 @@ var require_lodash = __commonJS({
         function wrapperValue() {
           return baseWrapperValue(this.__wrapped__, this.__actions__);
         }
-        var countBy = createAggregator(function(result2, value, key) {
-          if (hasOwnProperty.call(result2, key)) {
-            ++result2[key];
+        var countBy = createAggregator(function(result2, value, key2) {
+          if (hasOwnProperty.call(result2, key2)) {
+            ++result2[key2];
           } else {
-            baseAssignValue(result2, key, 1);
+            baseAssignValue(result2, key2, 1);
           }
         });
         function every(collection, predicate, guard) {
@@ -3692,11 +3692,11 @@ var require_lodash = __commonJS({
           var func = isArray(collection) ? arrayEachRight : baseEachRight;
           return func(collection, getIteratee(iteratee2, 3));
         }
-        var groupBy = createAggregator(function(result2, value, key) {
-          if (hasOwnProperty.call(result2, key)) {
-            result2[key].push(value);
+        var groupBy = createAggregator(function(result2, value, key2) {
+          if (hasOwnProperty.call(result2, key2)) {
+            result2[key2].push(value);
           } else {
-            baseAssignValue(result2, key, [value]);
+            baseAssignValue(result2, key2, [value]);
           }
         });
         function includes(collection, value, fromIndex, guard) {
@@ -3708,15 +3708,15 @@ var require_lodash = __commonJS({
           }
           return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
         }
-        var invokeMap = baseRest(function(collection, path68, args) {
-          var index = -1, isFunc = typeof path68 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
+        var invokeMap = baseRest(function(collection, path69, args) {
+          var index = -1, isFunc = typeof path69 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
           baseEach(collection, function(value) {
-            result2[++index] = isFunc ? apply(path68, value, args) : baseInvoke(value, path68, args);
+            result2[++index] = isFunc ? apply(path69, value, args) : baseInvoke(value, path69, args);
           });
           return result2;
         });
-        var keyBy = createAggregator(function(result2, value, key) {
-          baseAssignValue(result2, key, value);
+        var keyBy = createAggregator(function(result2, value, key2) {
+          baseAssignValue(result2, key2, value);
         });
         function map2(collection, iteratee2) {
           var func = isArray(collection) ? arrayMap : baseMap;
@@ -3735,8 +3735,8 @@ var require_lodash = __commonJS({
           }
           return baseOrderBy(collection, iteratees, orders);
         }
-        var partition = createAggregator(function(result2, value, key) {
-          result2[key ? 0 : 1].push(value);
+        var partition = createAggregator(function(result2, value, key2) {
+          result2[key2 ? 0 : 1].push(value);
         }, function() {
           return [[], []];
         });
@@ -3844,13 +3844,13 @@ var require_lodash = __commonJS({
           }
           return createWrap(func, bitmask, thisArg, partials, holders);
         });
-        var bindKey = baseRest(function(object2, key, partials) {
+        var bindKey = baseRest(function(object2, key2, partials) {
           var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
           if (partials.length) {
             var holders = replaceHolders(partials, getHolder(bindKey));
             bitmask |= WRAP_PARTIAL_FLAG;
           }
-          return createWrap(key, bitmask, object2, partials, holders);
+          return createWrap(key2, bitmask, object2, partials, holders);
         });
         function curry(func, arity, guard) {
           arity = guard ? undefined2 : arity;
@@ -3959,12 +3959,12 @@ var require_lodash = __commonJS({
             throw new TypeError2(FUNC_ERROR_TEXT);
           }
           var memoized = function() {
-            var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-            if (cache.has(key)) {
-              return cache.get(key);
+            var args = arguments, key2 = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+            if (cache.has(key2)) {
+              return cache.get(key2);
             }
             var result2 = func.apply(this, args);
-            memoized.cache = cache.set(key, result2) || cache;
+            memoized.cache = cache.set(key2, result2) || cache;
             return result2;
           };
           memoized.cache = new (memoize.Cache || MapCache)();
@@ -4122,8 +4122,8 @@ var require_lodash = __commonJS({
           if (isPrototype(value)) {
             return !baseKeys(value).length;
           }
-          for (var key in value) {
-            if (hasOwnProperty.call(value, key)) {
+          for (var key2 in value) {
+            if (hasOwnProperty.call(value, key2)) {
               return false;
             }
           }
@@ -4292,9 +4292,9 @@ var require_lodash = __commonJS({
             copyObject(source, keys(source), object2);
             return;
           }
-          for (var key in source) {
-            if (hasOwnProperty.call(source, key)) {
-              assignValue(object2, key, source[key]);
+          for (var key2 in source) {
+            if (hasOwnProperty.call(source, key2)) {
+              assignValue(object2, key2, source[key2]);
             }
           }
         });
@@ -4326,10 +4326,10 @@ var require_lodash = __commonJS({
             var propsIndex = -1;
             var propsLength = props.length;
             while (++propsIndex < propsLength) {
-              var key = props[propsIndex];
-              var value = object2[key];
-              if (value === undefined2 || eq(value, objectProto[key]) && !hasOwnProperty.call(object2, key)) {
-                object2[key] = source[key];
+              var key2 = props[propsIndex];
+              var value = object2[key2];
+              if (value === undefined2 || eq(value, objectProto[key2]) && !hasOwnProperty.call(object2, key2)) {
+                object2[key2] = source[key2];
               }
             }
           }
@@ -4363,30 +4363,30 @@ var require_lodash = __commonJS({
         function functionsIn(object2) {
           return object2 == null ? [] : baseFunctions(object2, keysIn(object2));
         }
-        function get(object2, path68, defaultValue) {
-          var result2 = object2 == null ? undefined2 : baseGet(object2, path68);
+        function get(object2, path69, defaultValue) {
+          var result2 = object2 == null ? undefined2 : baseGet(object2, path69);
           return result2 === undefined2 ? defaultValue : result2;
         }
-        function has(object2, path68) {
-          return object2 != null && hasPath(object2, path68, baseHas);
+        function has(object2, path69) {
+          return object2 != null && hasPath(object2, path69, baseHas);
         }
-        function hasIn(object2, path68) {
-          return object2 != null && hasPath(object2, path68, baseHasIn);
+        function hasIn(object2, path69) {
+          return object2 != null && hasPath(object2, path69, baseHasIn);
         }
-        var invert = createInverter(function(result2, value, key) {
+        var invert = createInverter(function(result2, value, key2) {
           if (value != null && typeof value.toString != "function") {
             value = nativeObjectToString.call(value);
           }
-          result2[value] = key;
+          result2[value] = key2;
         }, constant(identity));
-        var invertBy = createInverter(function(result2, value, key) {
+        var invertBy = createInverter(function(result2, value, key2) {
           if (value != null && typeof value.toString != "function") {
             value = nativeObjectToString.call(value);
           }
           if (hasOwnProperty.call(result2, value)) {
-            result2[value].push(key);
+            result2[value].push(key2);
           } else {
-            result2[value] = [key];
+            result2[value] = [key2];
           }
         }, getIteratee);
         var invoke = baseRest(baseInvoke);
@@ -4399,16 +4399,16 @@ var require_lodash = __commonJS({
         function mapKeys(object2, iteratee2) {
           var result2 = {};
           iteratee2 = getIteratee(iteratee2, 3);
-          baseForOwn(object2, function(value, key, object3) {
-            baseAssignValue(result2, iteratee2(value, key, object3), value);
+          baseForOwn(object2, function(value, key2, object3) {
+            baseAssignValue(result2, iteratee2(value, key2, object3), value);
           });
           return result2;
         }
         function mapValues(object2, iteratee2) {
           var result2 = {};
           iteratee2 = getIteratee(iteratee2, 3);
-          baseForOwn(object2, function(value, key, object3) {
-            baseAssignValue(result2, key, iteratee2(value, key, object3));
+          baseForOwn(object2, function(value, key2, object3) {
+            baseAssignValue(result2, key2, iteratee2(value, key2, object3));
           });
           return result2;
         }
@@ -4424,10 +4424,10 @@ var require_lodash = __commonJS({
             return result2;
           }
           var isDeep = false;
-          paths = arrayMap(paths, function(path68) {
-            path68 = castPath(path68, object2);
-            isDeep || (isDeep = path68.length > 1);
-            return path68;
+          paths = arrayMap(paths, function(path69) {
+            path69 = castPath(path69, object2);
+            isDeep || (isDeep = path69.length > 1);
+            return path69;
           });
           copyObject(object2, getAllKeysIn(object2), result2);
           if (isDeep) {
@@ -4453,19 +4453,19 @@ var require_lodash = __commonJS({
             return [prop];
           });
           predicate = getIteratee(predicate);
-          return basePickBy(object2, props, function(value, path68) {
-            return predicate(value, path68[0]);
+          return basePickBy(object2, props, function(value, path69) {
+            return predicate(value, path69[0]);
           });
         }
-        function result(object2, path68, defaultValue) {
-          path68 = castPath(path68, object2);
-          var index = -1, length = path68.length;
+        function result(object2, path69, defaultValue) {
+          path69 = castPath(path69, object2);
+          var index = -1, length = path69.length;
           if (!length) {
             length = 1;
             object2 = undefined2;
           }
           while (++index < length) {
-            var value = object2 == null ? undefined2 : object2[toKey(path68[index])];
+            var value = object2 == null ? undefined2 : object2[toKey(path69[index])];
             if (value === undefined2) {
               index = length;
               value = defaultValue;
@@ -4474,12 +4474,12 @@ var require_lodash = __commonJS({
           }
           return object2;
         }
-        function set2(object2, path68, value) {
-          return object2 == null ? object2 : baseSet(object2, path68, value);
+        function set2(object2, path69, value) {
+          return object2 == null ? object2 : baseSet(object2, path69, value);
         }
-        function setWith(object2, path68, value, customizer) {
+        function setWith(object2, path69, value, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object2 == null ? object2 : baseSet(object2, path68, value, customizer);
+          return object2 == null ? object2 : baseSet(object2, path69, value, customizer);
         }
         var toPairs = createToPairs(keys);
         var toPairsIn = createToPairs(keysIn);
@@ -4501,15 +4501,15 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function unset(object2, path68) {
-          return object2 == null ? true : baseUnset(object2, path68);
+        function unset(object2, path69) {
+          return object2 == null ? true : baseUnset(object2, path69);
         }
-        function update(object2, path68, updater) {
-          return object2 == null ? object2 : baseUpdate(object2, path68, castFunction(updater));
+        function update(object2, path69, updater) {
+          return object2 == null ? object2 : baseUpdate(object2, path69, castFunction(updater));
         }
-        function updateWith(object2, path68, updater, customizer) {
+        function updateWith(object2, path69, updater, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object2 == null ? object2 : baseUpdate(object2, path68, castFunction(updater), customizer);
+          return object2 == null ? object2 : baseUpdate(object2, path69, castFunction(updater), customizer);
         }
         function values(object2) {
           return object2 == null ? [] : baseValues(object2, keys(object2));
@@ -4693,8 +4693,8 @@ var require_lodash = __commonJS({
           string4 = toString(string4);
           options = assignWith({}, options, settings, customDefaultsAssignIn);
           var imports = assignWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
-          arrayEach(importsKeys, function(key) {
-            if (reForbiddenIdentifierChars.test(key)) {
+          arrayEach(importsKeys, function(key2) {
+            if (reForbiddenIdentifierChars.test(key2)) {
               throw new Error2(INVALID_TEMPL_IMPORTS_ERROR_TEXT);
             }
           });
@@ -4849,9 +4849,9 @@ var require_lodash = __commonJS({
           }
         });
         var bindAll = flatRest(function(object2, methodNames) {
-          arrayEach(methodNames, function(key) {
-            key = toKey(key);
-            baseAssignValue(object2, key, bind(object2[key], object2));
+          arrayEach(methodNames, function(key2) {
+            key2 = toKey(key2);
+            baseAssignValue(object2, key2, bind(object2[key2], object2));
           });
           return object2;
         });
@@ -4895,17 +4895,17 @@ var require_lodash = __commonJS({
         function matches(source) {
           return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
         }
-        function matchesProperty(path68, srcValue) {
-          return baseMatchesProperty(path68, baseClone(srcValue, CLONE_DEEP_FLAG));
+        function matchesProperty(path69, srcValue) {
+          return baseMatchesProperty(path69, baseClone(srcValue, CLONE_DEEP_FLAG));
         }
-        var method = baseRest(function(path68, args) {
+        var method = baseRest(function(path69, args) {
           return function(object2) {
-            return baseInvoke(object2, path68, args);
+            return baseInvoke(object2, path69, args);
           };
         });
         var methodOf = baseRest(function(object2, args) {
-          return function(path68) {
-            return baseInvoke(object2, path68, args);
+          return function(path69) {
+            return baseInvoke(object2, path69, args);
           };
         });
         function mixin(object2, source, options) {
@@ -4952,12 +4952,12 @@ var require_lodash = __commonJS({
         var over = createOver(arrayMap);
         var overEvery = createOver(arrayEvery);
         var overSome = createOver(arraySome);
-        function property(path68) {
-          return isKey(path68) ? baseProperty(toKey(path68)) : basePropertyDeep(path68);
+        function property(path69) {
+          return isKey(path69) ? baseProperty(toKey(path69)) : basePropertyDeep(path69);
         }
         function propertyOf(object2) {
-          return function(path68) {
-            return object2 == null ? undefined2 : baseGet(object2, path68);
+          return function(path69) {
+            return object2 == null ? undefined2 : baseGet(object2, path69);
           };
         }
         var range = createRange();
@@ -5410,12 +5410,12 @@ var require_lodash = __commonJS({
         LazyWrapper.prototype.findLast = function(predicate) {
           return this.reverse().find(predicate);
         };
-        LazyWrapper.prototype.invokeMap = baseRest(function(path68, args) {
-          if (typeof path68 == "function") {
+        LazyWrapper.prototype.invokeMap = baseRest(function(path69, args) {
+          if (typeof path69 == "function") {
             return new LazyWrapper(this);
           }
           return this.map(function(value) {
-            return baseInvoke(value, path68, args);
+            return baseInvoke(value, path69, args);
           });
         });
         LazyWrapper.prototype.reject = function(predicate) {
@@ -5488,11 +5488,11 @@ var require_lodash = __commonJS({
         baseForOwn(LazyWrapper.prototype, function(func, methodName) {
           var lodashFunc = lodash[methodName];
           if (lodashFunc) {
-            var key = lodashFunc.name + "";
-            if (!hasOwnProperty.call(realNames, key)) {
-              realNames[key] = [];
+            var key2 = lodashFunc.name + "";
+            if (!hasOwnProperty.call(realNames, key2)) {
+              realNames[key2] = [];
             }
-            realNames[key].push({ "name": methodName, "func": lodashFunc });
+            realNames[key2].push({ "name": methodName, "func": lodashFunc });
           }
         });
         realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{
@@ -6272,9 +6272,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key, getter) {
+function defineLazy(object2, key2, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key, {
+  Object.defineProperty(object2, key2, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -6286,7 +6286,7 @@ function defineLazy(object2, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object2, key, {
+      Object.defineProperty(object2, key2, {
         value: v
         // configurable: true,
       });
@@ -6312,47 +6312,47 @@ function rawShape(def) {
 function sourceShape(schema) {
   return rawShape(schema._zod.def) ?? schema._zod.def.shape;
 }
-function deferProp(target, key, getter) {
-  Object.defineProperty(target, key, {
+function deferProp(target, key2, getter) {
+  Object.defineProperty(target, key2, {
     get() {
       const value = getter();
-      assignProp(this, key, value);
+      assignProp(this, key2, value);
       return value;
     },
     enumerable: true,
     configurable: true
   });
 }
-function putProp(target, key, value) {
-  if (key in target)
-    assignProp(target, key, value);
+function putProp(target, key2, value) {
+  if (key2 in target)
+    assignProp(target, key2, value);
   else
-    target[key] = value;
+    target[key2] = value;
 }
 function mirrorShape(target, source, keys, wrap) {
   const raw = sourceShape(source);
-  for (const key of keys) {
-    const desc = Object.getOwnPropertyDescriptor(raw, key);
+  for (const key2 of keys) {
+    const desc = Object.getOwnPropertyDescriptor(raw, key2);
     if (!desc.enumerable)
       continue;
     if (desc.get) {
-      deferProp(target, key, () => {
-        const value = source._zod.def.shape[key];
-        return wrap ? wrap(value, key) : value;
+      deferProp(target, key2, () => {
+        const value = source._zod.def.shape[key2];
+        return wrap ? wrap(value, key2) : value;
       });
     } else
-      putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
+      putProp(target, key2, wrap ? wrap(desc.value, key2) : desc.value);
   }
 }
 function mirrorProps(target, source) {
-  for (const key of Reflect.ownKeys(source)) {
-    const desc = Object.getOwnPropertyDescriptor(source, key);
+  for (const key2 of Reflect.ownKeys(source)) {
+    const desc = Object.getOwnPropertyDescriptor(source, key2);
     if (!desc.enumerable)
       continue;
     if (desc.get)
-      deferProp(target, key, () => source[key]);
+      deferProp(target, key2, () => source[key2]);
     else
-      putProp(target, key, desc.value);
+      putProp(target, key2, desc.value);
   }
 }
 function mergeDefs(...defs) {
@@ -6366,14 +6366,14 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path68) {
-  if (!path68)
+function getElementAtPath(obj, path69) {
+  if (!path69)
     return obj;
-  return path68.reduce((acc, key) => acc?.[key], obj);
+  return path69.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const promises = keys.map((key2) => promisesObj[key2]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
@@ -6445,8 +6445,8 @@ function shallowClone(o) {
 }
 function numKeys(data) {
   let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
+  for (const key2 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key2)) {
       keyCount++;
     }
   }
@@ -6600,12 +6600,12 @@ function pick(schema, mask) {
 function maskedKeys(schema, mask) {
   const raw = sourceShape(schema);
   const keys = [];
-  for (const key of Reflect.ownKeys(mask)) {
-    if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
-      throw new Error(`Unrecognized key: "${String(key)}"`);
+  for (const key2 of Reflect.ownKeys(mask)) {
+    if (!Object.getOwnPropertyDescriptor(raw, key2)?.enumerable) {
+      throw new Error(`Unrecognized key: "${String(key2)}"`);
     }
-    if (mask[key])
-      keys.push(key);
+    if (mask[key2])
+      keys.push(key2);
   }
   return keys;
 }
@@ -6618,7 +6618,7 @@ function omit(schema, mask) {
   }
   const omitted = new Set(maskedKeys(schema, mask));
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
+  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key2) => !omitted.has(key2)));
   return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
 }
 function extend(schema, shape) {
@@ -6629,8 +6629,8 @@ function extend(schema, shape) {
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     const existingShape = sourceShape(schema);
-    for (const key of Reflect.ownKeys(shape)) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
+    for (const key2 of Reflect.ownKeys(shape)) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key2) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
@@ -6677,15 +6677,15 @@ function partial(Class2, schema, mask, name = "partial") {
   }
   const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class2 && ((value, key) => selected && !selected.has(key) ? value : new Class2({ type: "optional", innerType: value })));
+  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class2 && ((value, key2) => selected && !selected.has(key2) ? value : new Class2({ type: "optional", innerType: value })));
   return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] }));
 }
 function required(Class2, schema, mask) {
   const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => (
+  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key2) => (
     // overwrite with non-optional
-    selected && !selected.has(key) ? value : new Class2({ type: "nonoptional", innerType: value })
+    selected && !selected.has(key2) ? value : new Class2({ type: "nonoptional", innerType: value })
   ));
   return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
 }
@@ -6709,11 +6709,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path68, issues) {
+function prefixIssues(path69, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path68);
+    iss.path.unshift(path69);
     return iss;
   });
 }
@@ -6860,46 +6860,46 @@ var Class = class {
   }
 };
 function members(proto, table) {
-  for (const key in table) {
-    const desc = Object.getOwnPropertyDescriptor(table, key);
+  for (const key2 in table) {
+    const desc = Object.getOwnPropertyDescriptor(table, key2);
     if (desc.get)
-      Object.defineProperty(proto, key, { ...desc, enumerable: false });
+      Object.defineProperty(proto, key2, { ...desc, enumerable: false });
     else
-      defineBound(proto, key, desc.value);
+      defineBound(proto, key2, desc.value);
   }
 }
-function own(inst, key, value, enumerable = true) {
-  Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
+function own(inst, key2, value, enumerable = true) {
+  Object.defineProperty(inst, key2, { configurable: true, writable: true, enumerable, value });
   return value;
 }
-function hide(inst, key, value) {
-  return own(inst, key, value, false);
+function hide(inst, key2, value) {
+  return own(inst, key2, value, false);
 }
 // @__NO_SIDE_EFFECTS__
 function derived(computes, table) {
-  for (const key in computes) {
-    const compute = computes[key];
-    Object.defineProperty(table, key, {
+  for (const key2 in computes) {
+    const compute = computes[key2];
+    Object.defineProperty(table, key2, {
       configurable: true,
       enumerable: true,
       get() {
-        return own(this, key, compute(this));
+        return own(this, key2, compute(this));
       },
       set(value) {
-        own(this, key, value);
+        own(this, key2, value);
       }
     });
   }
   return table;
 }
-function defineBound(proto, key, fn) {
-  Object.defineProperty(proto, key, {
+function defineBound(proto, key2, fn) {
+  Object.defineProperty(proto, key2, {
     configurable: true,
     get() {
-      return this == null ? fn : own(this, key, fn.bind(this));
+      return this == null ? fn : own(this, key2, fn.bind(this));
     },
     set(value) {
-      own(this, key, value);
+      own(this, key2, value);
     }
   });
 }
@@ -6916,53 +6916,53 @@ var breaker = {
     return void 0;
   }
 };
-function defineLazyInternal(inst, key, compute) {
+function defineLazyInternal(inst, key2, compute) {
   const proto = Object.getPrototypeOf(inst._zod);
-  if (key in proto && installing !== inst._zod) {
+  if (key2 in proto && installing !== inst._zod) {
     installing = void 0;
     return;
   }
   installing = inst._zod;
-  Object.defineProperty(proto, key, {
+  Object.defineProperty(proto, key2, {
     configurable: true,
     get() {
-      Object.defineProperty(this, key, breaker);
+      Object.defineProperty(this, key2, breaker);
       const outer = broke;
       broke = false;
       try {
         const value = compute(this);
         if (broke)
-          delete this[key];
+          delete this[key2];
         else
-          Object.defineProperty(this, key, { configurable: true, writable: true, value });
+          Object.defineProperty(this, key2, { configurable: true, writable: true, value });
         broke = broke || outer;
         return value;
       } catch (err) {
-        delete this[key];
+        delete this[key2];
         broke = broke || outer;
         throw err;
       }
     },
     set(value) {
-      Object.defineProperty(this, key, { configurable: true, writable: true, value });
+      Object.defineProperty(this, key2, { configurable: true, writable: true, value });
     }
   });
 }
-function installLazyProp(inst, key, make, enumerable) {
-  const proto = claim(inst, key);
+function installLazyProp(inst, key2, make, enumerable) {
+  const proto = claim(inst, key2);
   if (!proto)
     return;
-  Object.defineProperty(proto, key, {
+  Object.defineProperty(proto, key2, {
     configurable: true,
     get() {
       const desc = { configurable: true, writable: true, enumerable, value: void 0 };
-      Object.defineProperty(this, key, desc);
+      Object.defineProperty(this, key2, desc);
       desc.value = make(this);
-      Object.defineProperty(this, key, desc);
+      Object.defineProperty(this, key2, desc);
       return desc.value;
     },
     set(value) {
-      Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
+      Object.defineProperty(this, key2, { configurable: true, writable: true, enumerable, value });
     }
   });
 }
@@ -7139,15 +7139,15 @@ var $ZodError = $constructor("$ZodError", initializer);
 var $ZodRealError = $constructor("$ZodError", initializer, void 0, {
   Parent: Error
 });
-function node(obj, key, make) {
-  if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-    if (key === "__proto__") {
-      Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
+function node(obj, key2, make) {
+  if (!Object.prototype.hasOwnProperty.call(obj, key2)) {
+    if (key2 === "__proto__") {
+      Object.defineProperty(obj, key2, { value: make(), writable: true, enumerable: true, configurable: true });
     } else {
-      obj[key] = make();
+      obj[key2] = make();
     }
   }
-  return obj[key];
+  return obj[key2];
 }
 function flattenError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = {};
@@ -7163,16 +7163,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path68 = []) => {
+  const processError = (error63, path69 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path68, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path69, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path69, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path69, ...issue2.path]);
       } else {
-        const fullpath = [...path68, ...issue2.path];
+        const fullpath = [...path69, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7211,17 +7211,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path68 = []) => {
+  const processError = (error63, path69 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path68, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path69, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path69, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path69, ...issue2.path]);
       } else {
-        const fullpath = [...path68, ...issue2.path];
+        const fullpath = [...path69, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7260,8 +7260,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path68 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path68) {
+  const path69 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path69) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -8056,16 +8056,16 @@ var $ZodCheckProperties = /* @__PURE__ */ $constructor("$ZodCheckProperties", (i
       payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
       return void 0;
     }
-    entries2 ?? (entries2 = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
+    entries2 ?? (entries2 = Reflect.ownKeys(def.shape).map((key2) => [key2, def.shape[key2]]));
     const input2 = payload.value;
     let proms;
-    for (const [key, schema] of entries2) {
-      const result = schema._zod.run({ value: input2[key], issues: [] }, {});
+    for (const [key2, schema] of entries2) {
+      const result = schema._zod.run({ value: input2[key2], issues: [] }, {});
       if (result instanceof Promise) {
         proms ?? (proms = []);
-        proms.push(result.then((result2) => handleCheckPropertyResult(result2, payload, key)));
+        proms.push(result.then((result2) => handleCheckPropertyResult(result2, payload, key2)));
       } else {
-        handleCheckPropertyResult(result, payload, key);
+        handleCheckPropertyResult(result, payload, key2);
       }
     }
     if (proms)
@@ -8940,8 +8940,8 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input2, optin, optout) {
-  const isPresent = key in input2;
+function handlePropertyResult(result, final, key2, input2, optin, optout) {
+  const isPresent = key2 in input2;
   const isOptionalOut = optout === "optional";
   if (!isPresent && isOptionalOut && optin === "optional") {
     return;
@@ -8950,7 +8950,7 @@ function handlePropertyResult(result, final, key, input2, optin, optout) {
     if (optin !== void 0 && isOptionalOut && !isPresent) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key2, result.issues));
   }
   if (!isPresent && optin === void 0) {
     if (!result.issues.length) {
@@ -8958,17 +8958,17 @@ function handlePropertyResult(result, final, key, input2, optin, optout) {
         code: "invalid_type",
         expected: "nonoptional",
         input: void 0,
-        path: [key]
+        path: [key2]
       });
     }
     return;
   }
   if (result.value === void 0) {
     if (isPresent || optin === "defaulted" && !isOptionalOut) {
-      final.value[key] = void 0;
+      final.value[key2] = void 0;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key2] = result.value;
   }
 }
 var NO_SYMBOL_KEYS = [];
@@ -9001,28 +9001,28 @@ function handleCatchall(proms, input2, payload, ctx, def, inst, abortEarly) {
   const optin = _catchall.optin;
   const optout = _catchall.optout;
   let seen = 0;
-  for (const key in input2) {
+  for (const key2 in input2) {
     if (abortEarly && payload.issues.length !== seen) {
       if (aborted(payload, seen))
         break;
       seen = payload.issues.length;
     }
-    if (keySet.has(key))
+    if (keySet.has(key2))
       continue;
-    if (key === "__proto__") {
+    if (key2 === "__proto__") {
       if (t === "never")
-        unrecognized.push(key);
+        unrecognized.push(key2);
       continue;
     }
     if (t === "never") {
-      unrecognized.push(key);
+      unrecognized.push(key2);
       continue;
     }
-    const r = _catchall.run({ value: input2[key], issues: [] }, ctx);
+    const r = _catchall.run({ value: input2[key2], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2, optin, optout)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input2, optin, optout)));
     } else {
-      handlePropertyResult(r, payload, key, input2, optin, optout);
+      handlePropertyResult(r, payload, key2, input2, optin, optout);
     }
   }
   if (unrecognized.length) {
@@ -9059,16 +9059,16 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   defineLazyInternal(inst, "propValues", (zod) => {
     const shape = zod.def.shape;
     const propValues = {};
-    for (const key in shape) {
-      const field2 = shape[key]._zod;
+    for (const key2 in shape) {
+      const field2 = shape[key2]._zod;
       if (field2.values) {
-        if (!Object.prototype.hasOwnProperty.call(propValues, key)) {
-          assignProp(propValues, key, /* @__PURE__ */ new Set());
+        if (!Object.prototype.hasOwnProperty.call(propValues, key2)) {
+          assignProp(propValues, key2, /* @__PURE__ */ new Set());
         }
         for (const v of field2.values)
-          propValues[key].add(v);
+          propValues[key2].add(v);
         if (field2.optin !== void 0)
-          propValues[key].add(void 0);
+          propValues[key2].add(void 0);
       }
     }
     return propValues;
@@ -9095,22 +9095,22 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = value.shape;
     const abortEarly = ctx?.abortEarly;
     let seen = payload.issues.length;
-    for (const key of value.allKeys) {
+    for (const key2 of value.allKeys) {
       if (abortEarly && payload.issues.length !== seen) {
         if (aborted(payload, seen))
           break;
         seen = payload.issues.length;
       }
-      if (key === "__proto__")
+      if (key2 === "__proto__")
         continue;
-      const el = shape[key];
+      const el = shape[key2];
       const optin = el._zod.optin;
       const optout = el._zod.optout;
-      const r = el._zod.run({ value: input2[key], issues: [] }, ctx);
+      const r = el._zod.run({ value: input2[key2], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2, optin, optout)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input2, optin, optout)));
       } else {
-        handlePropertyResult(r, payload, key, input2, optin, optout);
+        handlePropertyResult(r, payload, key2, input2, optin, optout);
       }
     }
     if (!catchall) {
@@ -9144,17 +9144,17 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.allKeys) {
-      ids[key] = `key_${counter++}`;
+    for (const key2 of normalized.allKeys) {
+      ids[key2] = `key_${counter++}`;
     }
     doc.write(memo2 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
-    for (const key of normalized.allKeys) {
-      if (key === "__proto__")
+    for (const key2 of normalized.allKeys) {
+      if (key2 === "__proto__")
         continue;
-      const id = ids[key];
-      const k = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc(key);
+      const id = ids[key2];
+      const k = typeof key2 === "symbol" ? `syms[${syms.indexOf(key2)}]` : esc(key2);
       const isPresent = `${k} in input`;
-      const schema = shape[key];
+      const schema = shape[key2];
       const optin = schema?._zod?.optin;
       const isOptionalIn = optin !== void 0;
       const isOptionalOut = schema?._zod?.optout === "optional";
@@ -9488,21 +9488,21 @@ function mergeValues(a, b) {
   }
   if (isPlainObject(a) && isPlainObject(b)) {
     const bKeys = Object.keys(b);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = Object.keys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
     const newObj = { ...a, ...b };
     if (Object.prototype.hasOwnProperty.call(newObj, "__proto__"))
       delete newObj.__proto__;
-    for (const key of sharedKeys) {
-      if (key === "__proto__")
+    for (const key2 of sharedKeys) {
+      if (key2 === "__proto__")
         continue;
-      const sharedValue = mergeValues(a[key], b[key]);
+      const sharedValue = mergeValues(a[key2], b[key2]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   }
@@ -9661,9 +9661,9 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return handleTupleResults(itemResults, payload, items, input2, optoutStart);
   };
 });
-function getTupleOptStart(items, key) {
+function getTupleOptStart(items, key2) {
   for (let i = items.length - 1; i >= 0; i--) {
-    const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
+    const omittable = key2 === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
     if (!omittable)
       return i + 1;
   }
@@ -9721,12 +9721,12 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     if (values && !def.partial) {
       payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
       const recordKeys = /* @__PURE__ */ new Set();
-      for (const key of values) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          recordKeys.add(typeof key === "number" ? key.toString() : key);
-          if (key === "__proto__")
+      for (const key2 of values) {
+        if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
+          recordKeys.add(typeof key2 === "number" ? key2.toString() : key2);
+          if (key2 === "__proto__")
             continue;
-          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
           if (keyResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -9735,8 +9735,8 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
             continue;
@@ -9744,32 +9744,32 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
           const outKey = keyResult.value;
           if (outKey === "__proto__")
             continue;
-          const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+          const result = def.valueType._zod.run({ value: input2[key2], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
+                payload.issues.push(...prefixIssues(key2, result2.issues));
               }
               payload.value[outKey] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
+              payload.issues.push(...prefixIssues(key2, result.issues));
             }
             payload.value[outKey] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key in input2) {
-        if (!recordKeys.has(key)) {
+      for (const key2 in input2) {
+        if (!recordKeys.has(key2)) {
           if (def.mode === "loose") {
-            if (key === "__proto__")
+            if (key2 === "__proto__")
               continue;
-            payload.value[key] = input2[key];
+            payload.value[key2] = input2[key2];
           } else {
             unrecognized = unrecognized ?? [];
-            unrecognized.push(key);
+            unrecognized.push(key2);
           }
         }
       }
@@ -9785,18 +9785,18 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     } else {
       payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
       let unrecognized;
-      for (const key of Reflect.ownKeys(input2)) {
-        if (key === "__proto__")
+      for (const key2 of Reflect.ownKeys(input2)) {
+        if (key2 === "__proto__")
           continue;
-        if (!Object.prototype.propertyIsEnumerable.call(input2, key))
+        if (!Object.prototype.propertyIsEnumerable.call(input2, key2))
           continue;
-        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+        const checkNumericKey = typeof key2 === "string" && number.test(key2) && keyResult.issues.length;
         if (checkNumericKey) {
-          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -9806,17 +9806,17 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         }
         if (keyResult.issues.length) {
           if (def.mode === "loose") {
-            payload.value[key] = input2[key];
+            payload.value[key2] = input2[key2];
           } else if (values) {
             unrecognized = unrecognized ?? [];
-            unrecognized.push(key);
+            unrecognized.push(key2);
           } else {
             payload.issues.push({
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
           }
@@ -9825,17 +9825,17 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         const outKey = keyResult.value;
         if (outKey === "__proto__")
           continue;
-        const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input2[key2], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+              payload.issues.push(...prefixIssues(key2, result2.issues));
             }
             payload.value[outKey] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
+            payload.issues.push(...prefixIssues(key2, result.issues));
           }
           payload.value[outKey] = result.value;
         }
@@ -9875,20 +9875,20 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     payload.value = memo2 ? memo2.alloc(inst, payload, /* @__PURE__ */ new Map(), ctx) : /* @__PURE__ */ new Map();
     const abortEarly = ctx?.abortEarly;
     let seen = payload.issues.length;
-    for (const [key, value] of input2) {
+    for (const [key2, value] of input2) {
       if (abortEarly && payload.issues.length !== seen) {
         if (aborted(payload, seen))
           break;
         seen = payload.issues.length;
       }
-      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+      const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
       if (keyResult instanceof Promise || valueResult instanceof Promise) {
         proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input2, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key2, input2, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key, input2, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key2, input2, inst, ctx);
       }
     }
     if (proms.length)
@@ -9896,10 +9896,10 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key2, input2, inst, ctx) {
   if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, keyResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, keyResult.issues));
     } else {
       final.issues.push({
         code: "invalid_key",
@@ -9911,15 +9911,15 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
     }
   }
   if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, valueResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, valueResult.issues));
     } else {
       final.issues.push({
         origin: "map",
         code: "invalid_element",
         input: input2,
         inst,
-        key,
+        key: key2,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
     }
@@ -10593,8 +10593,8 @@ function isRecursive(inst, stack, resolve2) {
   };
   const shape = (sh, spread) => {
     let answer = NONE;
-    for (const key of Reflect.ownKeys(sh)) {
-      const desc = Object.getOwnPropertyDescriptor(sh, key);
+    for (const key2 of Reflect.ownKeys(sh)) {
+      const desc = Object.getOwnPropertyDescriptor(sh, key2);
       if (spread && !desc.enumerable)
         continue;
       const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve2) : NONE;
@@ -10690,8 +10690,8 @@ function isRecursive(inst, stack, resolve2) {
       break;
     default: {
       kind;
-      for (const key in def) {
-        const desc = Object.getOwnPropertyDescriptor(def, key);
+      for (const key2 in def) {
+        const desc = Object.getOwnPropertyDescriptor(def, key2);
         if (!desc || desc.get)
           continue;
         const value = desc.value;
@@ -18824,11 +18824,11 @@ function generatePropertiesChecks(doc, ctx, def, accessor) {
   }
   doc.write(`if (${accessor} == null) return INVALID;`);
   const shape = def.shape;
-  for (const key of Reflect.ownKeys(shape)) {
-    const keyExpr = typeof key === "symbol" ? addConstant(ctx, key) : esc(key);
+  for (const key2 of Reflect.ownKeys(shape)) {
+    const keyExpr = typeof key2 === "symbol" ? addConstant(ctx, key2) : esc(key2);
     const inputVar = newVar(ctx);
     doc.write(`const ${inputVar} = ${accessor}[${keyExpr}];`);
-    compileChild(doc, ctx, shape[key], inputVar, false);
+    compileChild(doc, ctx, shape[key2], inputVar, false);
   }
 }
 function generatePropertyCheck(doc, ctx, def, accessor) {
@@ -19221,9 +19221,9 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
     throw new ZodCompileUnsupportedError('object shape key "__proto__"');
   }
   const propOutputs = /* @__PURE__ */ new Map();
-  for (const key of allKeys) {
-    const propSchema = propShape[key];
-    const kx = keyExpr(key);
+  for (const key2 of allKeys) {
+    const propSchema = propShape[key2];
+    const kx = keyExpr(key2);
     const inputVar = newVar(ctx);
     doc.write(`const ${inputVar} = ${accessor}[${kx}];`);
     if (propSchema._zod.optin !== void 0) {
@@ -19244,14 +19244,14 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
       } else {
         doc.write(`if (${outputVar2} === INVALID) return INVALID;`);
       }
-      propOutputs.set(key, outputVar2);
+      propOutputs.set(key2, outputVar2);
     } else {
       if (requiresPresenceCheck(propSchema)) {
         doc.write(`if (!(${kx} in ${accessor})) return INVALID;`);
       }
       const outputAccessor = compileChild(doc, ctx, propSchema, inputVar, buildsValue);
       if (outputAccessor !== null)
-        propOutputs.set(key, outputAccessor);
+        propOutputs.set(key2, outputAccessor);
     }
   }
   const catchall = def.catchall;
@@ -19666,9 +19666,9 @@ function generateTupleCheck(doc, ctx, schema, accessor) {
   }
   return outputVar;
 }
-function getTupleOptStart2(items, key) {
+function getTupleOptStart2(items, key2) {
   for (let i = items.length - 1; i >= 0; i--) {
-    const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
+    const omittable = key2 === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
     if (!omittable)
       return i + 1;
   }
@@ -19798,16 +19798,16 @@ function generateRecordCheck(doc, ctx, schema, accessor) {
   const keyValues = recordDef.partial ? void 0 : def.keyType._zod.values;
   if (keyValues) {
     const inputKeys = [];
-    for (const key of keyValues) {
-      if (!(typeof key === "string" || typeof key === "number" || typeof key === "symbol")) {
-        throw new ZodCompileUnsupportedError(`record key value ${String(key)}`);
+    for (const key2 of keyValues) {
+      if (!(typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol")) {
+        throw new ZodCompileUnsupportedError(`record key value ${String(key2)}`);
       }
-      const inputKey = typeof key === "number" ? key.toString() : key;
+      const inputKey = typeof key2 === "number" ? key2.toString() : key2;
       if (inputKey === "__proto__") {
         throw new ZodCompileUnsupportedError('record key "__proto__"');
       }
       inputKeys.push(inputKey);
-      const keyConst = addConstant(ctx, key);
+      const keyConst = addConstant(ctx, key2);
       const outKey = generateCheck(doc, ctx, def.keyType, keyConst);
       const valueVar = newVar(ctx);
       doc.write(`const ${valueVar} = ${accessor}[${literalPropertyKey(ctx, inputKey)}];`);
@@ -19885,10 +19885,10 @@ function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
   });
   doc.write(`}`);
 }
-function literalPropertyKey(ctx, key) {
-  if (typeof key === "string")
-    return esc(key);
-  return addConstant(ctx, key);
+function literalPropertyKey(ctx, key2) {
+  if (typeof key2 === "string")
+    return esc(key2);
+  return addConstant(ctx, key2);
 }
 function generateMapCheck(doc, ctx, schema, accessor) {
   const def = schema._zod.def;
@@ -21115,9 +21115,9 @@ function _stringFormat(Class2, format2, fnOrRegex, _params = {}) {
 // node_modules/zod/v4/core/to-json-schema.js
 function assignProps(target, ...sources) {
   for (const source of sources) {
-    for (const key of Reflect.ownKeys(source)) {
-      if (Object.prototype.propertyIsEnumerable.call(source, key)) {
-        assignProp(target, key, source[key]);
+    for (const key2 of Reflect.ownKeys(source)) {
+      if (Object.prototype.propertyIsEnumerable.call(source, key2)) {
+        assignProp(target, key2, source[key2]);
       }
     }
   }
@@ -21263,8 +21263,8 @@ function extractDefs(ctx, schema) {
     if (defId)
       seen.defId = defId;
     const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    for (const key2 in schema2) {
+      delete schema2[key2];
     }
     schema2.$ref = ref;
   };
@@ -21345,8 +21345,8 @@ function foldObjects(members2) {
   for (const member of members2) {
     if (typeof member !== "object" || member.type !== "object")
       return null;
-    for (const key in member) {
-      if (!FOLDABLE_KEYS.has(key))
+    for (const key2 in member) {
+      if (!FOLDABLE_KEYS.has(key2))
         return null;
     }
     objects.push(member);
@@ -21354,22 +21354,22 @@ function foldObjects(members2) {
   const properties = {};
   const required2 = /* @__PURE__ */ new Set();
   for (const object2 of objects) {
-    for (const key in object2.properties) {
-      if (Object.prototype.hasOwnProperty.call(properties, key))
+    for (const key2 in object2.properties) {
+      if (Object.prototype.hasOwnProperty.call(properties, key2))
         continue;
       const parts2 = [];
       for (const other of objects) {
-        const part = other.properties?.[key] ?? undeclaredConstraint(other);
+        const part = other.properties?.[key2] ?? undeclaredConstraint(other);
         if (part === null || part === void 0)
           continue;
         if (!parts2.some((seen) => JSON.stringify(seen) === JSON.stringify(part)))
           parts2.push(part);
       }
       const merged = parts2.length === 1 ? parts2[0] : foldObjects(parts2) ?? { allOf: parts2 };
-      assignProp(properties, key, merged);
+      assignProp(properties, key2, merged);
     }
-    for (const key of object2.required ?? [])
-      required2.add(key);
+    for (const key2 of object2.required ?? [])
+      required2.add(key2);
   }
   const folded = { type: "object", properties };
   if (required2.size)
@@ -21394,8 +21394,8 @@ function foldIntersection(json2) {
   const allOf = json2.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
-  for (const key of FOLDABLE_KEYS)
-    if (key in json2)
+  for (const key2 of FOLDABLE_KEYS)
+    if (key2 in json2)
       return;
   const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
   let folded = null;
@@ -21442,20 +21442,20 @@ function finalize(ctx, schema) {
       assignProps(schema2, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (!(key in _cached)) {
-            delete schema2[key];
+          if (!(key2 in _cached)) {
+            delete schema2[key2];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key2 in refSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(refSeen.def[key2])) {
+            delete schema2[key2];
           }
         }
       }
@@ -21467,11 +21467,11 @@ function finalize(ctx, schema) {
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
-            if (key === "$ref" || key === "allOf")
+          for (const key2 in schema2) {
+            if (key2 === "$ref" || key2 === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key2 in parentSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(parentSeen.def[key2])) {
+              delete schema2[key2];
             }
           }
         }
@@ -21604,8 +21604,8 @@ function isTransforming(_schema, _ctx) {
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
   if (def.type === "object") {
-    for (const key in def.shape) {
-      if (isTransforming(def.shape[key], ctx))
+    for (const key2 in def.shape) {
+      if (isTransforming(def.shape[key2], ctx))
         return true;
     }
     return false;
@@ -21643,13 +21643,13 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
 };
 
 // node_modules/zod/v4/core/json-schema-processors.js
-var narrowMin = (agg, key, value) => {
-  if (agg[key] === void 0 || value > agg[key])
-    agg[key] = value;
+var narrowMin = (agg, key2, value) => {
+  if (agg[key2] === void 0 || value > agg[key2])
+    agg[key2] = value;
 };
-var narrowMax = (agg, key, value) => {
-  if (agg[key] === void 0 || value < agg[key])
-    agg[key] = value;
+var narrowMax = (agg, key2, value) => {
+  if (agg[key2] === void 0 || value < agg[key2])
+    agg[key2] = value;
 };
 var narrowBoth = (agg, value) => {
   narrowMin(agg, "minimum", value);
@@ -21987,17 +21987,17 @@ var objectProcessor = (schema, ctx, _json, params) => {
   }
   json2.type = "object";
   json2.properties = {};
-  for (const key in shape) {
-    assignProp(json2.properties, key, processSchema(shape[key], ctx, {
+  for (const key2 in shape) {
+    assignProp(json2.properties, key2, processSchema(shape[key2], ctx, {
       ...params,
-      path: [...params.path, "properties", key]
+      path: [...params.path, "properties", key2]
     }));
   }
   const requiredKeys = [];
-  for (const key of Object.keys(shape)) {
-    const field2 = def.shape[key];
+  for (const key2 of Object.keys(shape)) {
+    const field2 = def.shape[key2];
     if (ctx.io === "input" ? inputOptin(field2) === void 0 : field2._zod.optout === void 0) {
-      requiredKeys.push(key);
+      requiredKeys.push(key2);
     }
   }
   if (requiredKeys.length > 0) {
@@ -22372,9 +22372,9 @@ function toJSONSchema(input2, params) {
     };
     ctx2.external = external;
     for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
+      const [key2, schema] = entry;
       extractDefs(ctx2, schema);
-      assignProp(schemas, key, finalize(ctx2, schema));
+      assignProp(schemas, key2, finalize(ctx2, schema));
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -22689,17 +22689,17 @@ __export(checks_exports2, {
 
 // node_modules/zod/v4/classic/errors.js
 var _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
-function _lazyMethod(proto, key, make) {
-  Object.defineProperty(proto, key, {
+function _lazyMethod(proto, key2, make) {
+  Object.defineProperty(proto, key2, {
     configurable: true,
     enumerable: false,
     get() {
       const value = make(this);
-      Object.defineProperty(this, key, { value, configurable: true, writable: true });
+      Object.defineProperty(this, key2, { value, configurable: true, writable: true });
       return value;
     },
     set(value) {
-      Object.defineProperty(this, key, { value, configurable: true, writable: true });
+      Object.defineProperty(this, key2, { value, configurable: true, writable: true });
     }
   });
 }
@@ -24363,17 +24363,17 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path68 = ref.slice(1).split("/").filter(Boolean);
-  if (path68.length === 0) {
+  const path69 = ref.slice(1).split("/").filter(Boolean);
+  if (path69.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path68[0] === defsKey) {
-    const key = path68[1] === void 0 ? void 0 : decodeJSONPointerSegment(path68[1]);
-    if (!key || !ctx.defs[key]) {
+  if (path69[0] === defsKey) {
+    const key2 = path69[1] === void 0 ? void 0 : decodeJSONPointerSegment(path69[1]);
+    if (!key2 || !ctx.defs[key2]) {
       throw new Error(`Reference not found: ${ref}`);
     }
-    return ctx.defs[key];
+    return ctx.defs[key2];
   }
   throw new Error(`Reference not found: ${ref}`);
 }
@@ -24408,16 +24408,16 @@ function checkObjectGuards(objectSchema, guards) {
       });
     }
     if (guards.keySchema) {
-      for (const key of keys) {
-        const result = guards.keySchema.safeParse(key);
+      for (const key2 of keys) {
+        const result = guards.keySchema.safeParse(key2);
         if (result.success)
           continue;
         payload.issues.push({
           code: "invalid_key",
           origin: "record",
           issues: result.error.issues,
-          input: key,
-          path: [key],
+          input: key2,
+          path: [key2],
           continue: true
         });
       }
@@ -24442,20 +24442,20 @@ function canonicalKey(value, seen) {
     if (Array.isArray(value)) {
       const parts3 = [];
       for (const item of value) {
-        const key = canonicalKey(item, seen);
-        if (key === null)
+        const key2 = canonicalKey(item, seen);
+        if (key2 === null)
           return null;
-        parts3.push(key);
+        parts3.push(key2);
       }
       return `a${parts3.length}:[${parts3.join(",")}]`;
     }
     const keys = Object.keys(value).sort();
     const parts2 = [];
     for (const k of keys) {
-      const key = canonicalKey(value[k], seen);
-      if (key === null)
+      const key2 = canonicalKey(value[k], seen);
+      if (key2 === null)
         return null;
-      parts2.push(`${k.length}:${k}=${key}`);
+      parts2.push(`${k.length}:${k}=${key2}`);
     }
     return `o${parts2.length}:{${parts2.join(",")}}`;
   } finally {
@@ -24495,10 +24495,10 @@ function containsRef(value) {
     return value.some(containsRef);
   if (typeof value.$ref === "string")
     return true;
-  return Object.entries(value).some(([key, sub]) => {
-    if (SCHEMA_KEYWORDS.has(key))
+  return Object.entries(value).some(([key2, sub]) => {
+    if (SCHEMA_KEYWORDS.has(key2))
       return containsRef(sub);
-    if (!SCHEMA_MAP_KEYWORDS.has(key) || typeof sub !== "object" || sub === null)
+    if (!SCHEMA_MAP_KEYWORDS.has(key2) || typeof sub !== "object" || sub === null)
       return false;
     return Object.values(sub).some(containsRef);
   });
@@ -24514,12 +24514,12 @@ function checkArrayGuards(arraySchema, guards) {
     if (guards.uniqueItems === true) {
       const firstSeen = /* @__PURE__ */ new Map();
       for (let i = 0; i < items.length; i++) {
-        const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
-        if (key === null)
+        const key2 = canonicalKey(items[i], /* @__PURE__ */ new Set());
+        if (key2 === null)
           continue;
-        const first = firstSeen.get(key);
+        const first = firstSeen.get(key2);
         if (first === void 0) {
-          firstSeen.set(key, i);
+          firstSeen.set(key2, i);
           continue;
         }
         payload.issues.push({
@@ -24758,9 +24758,9 @@ function convertBaseSchema(schema, ctx) {
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
       const additionalSchema = typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : void 0;
-      for (const [key, propSchema] of Object.entries(properties)) {
+      for (const [key2, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
-        assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
+        assignProp(shape, key2, requiredSet.has(key2) ? propZodSchema : propZodSchema.optional());
       }
       if (schema.patternProperties) {
         const patternProps = schema.patternProperties;
@@ -24795,12 +24795,12 @@ function convertBaseSchema(schema, ctx) {
             if (!isPlainObject(payload.value))
               return;
             const unrecognized = [];
-            for (const key of Object.keys(payload.value)) {
-              if (propertyKeys.includes(key))
+            for (const key2 of Object.keys(payload.value)) {
+              if (propertyKeys.includes(key2))
                 continue;
-              if (patterns.some((regex) => regex.test(key)))
+              if (patterns.some((regex) => regex.test(key2)))
                 continue;
-              unrecognized.push(key);
+              unrecognized.push(key2);
             }
             if (unrecognized.length) {
               payload.issues.push({
@@ -24931,38 +24931,38 @@ function convertSchema(schema, ctx) {
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of coreMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of contentMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
   if (schema.type === "object" && schema.$ref === void 0) {
     if (schema.propertyNames !== void 0 && !containsRef(schema.propertyNames)) {
       extraMeta.propertyNames = schema.propertyNames;
     }
-    for (const key of ["minProperties", "maxProperties"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
+    for (const key2 of ["minProperties", "maxProperties"]) {
+      if (schema[key2] !== void 0)
+        extraMeta[key2] = schema[key2];
     }
   }
   if (schema.type === "array" && schema.$ref === void 0) {
     if (schema.contains !== void 0 && !containsRef(schema.contains)) {
       extraMeta.contains = schema.contains;
     }
-    for (const key of ["uniqueItems", "minContains", "maxContains"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
+    for (const key2 of ["uniqueItems", "minContains", "maxContains"]) {
+      if (schema[key2] !== void 0)
+        extraMeta[key2] = schema[key2];
     }
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      assignProp(extraMeta, key, schema[key]);
+  for (const key2 of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key2)) {
+      assignProp(extraMeta, key2, schema[key2]);
     }
   }
   if (Object.keys(extraMeta).length > 0) {
@@ -25257,9 +25257,9 @@ function profileLinkPairs(agent, dirs, profileRoot2, stateRoot) {
   const seen = /* @__PURE__ */ new Set();
   return dirs.flatMap((dir) => {
     const link = path.join(profileRoot2, ...parts(dir));
-    const key = link.toLowerCase();
-    if (seen.has(key)) return [];
-    seen.add(key);
+    const key2 = link.toLowerCase();
+    if (seen.has(key2)) return [];
+    seen.add(key2);
     return [{ link, target: path.join(state, ...parts(dir)) }];
   });
 }
@@ -25398,6 +25398,9 @@ var HarnessSchema = external_exports.strictObject({
   localState: external_exports.record(external_exports.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), SubfolderSchema).optional().describe(
     "Environment variable -> folder below the agent's own state folder (state\\<agent>) for SQLite databases. SQLite cannot run in a mapped folder, so the agent runs from a copy on the sandbox's disk (the variable points to it) that is copied from and back to that folder."
   ),
+  bootReset: external_exports.array(SubfolderSchema).max(32).optional().describe(
+    "Files and folders below the agent's own state folder (state\\<agent>) that only work on the machine that wrote them (keys sealed with Windows DPAPI, local accounts it created). Every sandbox is a new machine, so they are deleted at each boot and the agent sets them up again."
+  ),
   resumeArguments: StringsSchema.optional().describe(
     "Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation."
   ),
@@ -25475,6 +25478,9 @@ var MappingSchema = external_exports.strictObject({
   optional: external_exports.boolean().optional().describe("true = skip it quietly when the host folder does not exist.")
 });
 var SandboxSchema = external_exports.strictObject({
+  engine: external_exports.enum(["windows-sandbox", "hcs"]).describe(
+    '(alpha) What runs the sandbox. "windows-sandbox" = Windows Sandbox (the default: desktop, Windows Terminal, GPU, clipboard, audio, printers). "hcs" = a headless Hyper-V isolated Server Core container for agents (no desktop, GPU or clipboard); it needs Windows features and an image on this PC (sandbox engine check hcs lists what is missing), and starting it is not enabled yet in this alpha. sandbox engine shows what each engine can do. Yours only: a project file (.sandbox-config.json) cannot set it.'
+  ),
   memoryMb: external_exports.union([external_exports.literal("auto"), external_exports.number().int().min(2048)]).describe('Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb.'),
   maxMemoryMb: external_exports.number().int().positive().describe('Upper limit for memoryMb "auto".'),
   maxMemoryPercent: external_exports.number().int().min(10).max(100).describe(`memoryMb "auto" never takes more than this share of this PC's total RAM (percent).`),
@@ -25484,10 +25490,22 @@ var SandboxSchema = external_exports.strictObject({
   pageFileMb: external_exports.number().int().min(0).max(262144).describe(
     `Size of the sandbox's paging file in MB, created at full size when it starts so it never grows while builds run (8 GB of its disk always stays free). Windows Sandbox starts with about 1 GB: parallel builds then fail with "The paging file is too small", and Windows grows the file under load. 0 = leave Windows' own.`
   ),
-  reserveHostMb: external_exports.number().int().nonnegative().describe('RAM always left for this PC when memoryMb is "auto".'),
-  vGpu: external_exports.boolean().describe("Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface."),
+  reserveHostMb: external_exports.number().int().nonnegative().describe(
+    'Memory always left for this PC when memoryMb is "auto": the sandbox gets at most (free RAM, and RAM plus paging file still unused) minus this.'
+  ),
+  agentMemoryHeadroomMb: external_exports.union([external_exports.literal("auto"), external_exports.literal("none"), external_exports.number().int().min(0)]).describe(
+    'Memory kept out of the agents reach inside the sandbox, in MB: everything the agents start (their builds, tests, tools) together may use at most the sandbox memory minus this; a runaway parallel build then gets out-of-memory errors in its own session instead of freezing or crashing the whole sandbox. "auto" = the larger of 2048 MB and 10 % of the sandbox memory; "none" = no limit. Yours only: a project file cannot change it.'
+  ),
+  pressureResponse: external_exports.boolean().describe(
+    "When the sandbox (or this PC) runs low on memory, slow the heaviest build programs down (lower priority) and, if that is not enough, pause the biggest compiler for a few seconds at a time, so heavy parallel builds slow down instead of closing the sandbox. Never touches the agents themselves. Yours only: a project file cannot change it."
+  ),
+  vGpu: external_exports.boolean().describe(
+    "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it)."
+  ),
   networking: external_exports.boolean().describe("Internet access. false is the only hard network isolation Windows Sandbox offers."),
-  clipboard: external_exports.boolean().describe("Shared clipboard between this PC and the sandbox."),
+  clipboard: external_exports.boolean().describe(
+    "Shared clipboard between this PC and the sandbox. Also lets an agent's copy (in sandbox attach) reach this PC's clipboard."
+  ),
   audioInput: external_exports.boolean().describe("Microphone access."),
   videoInput: external_exports.boolean().describe("Camera access."),
   printerRedirection: external_exports.boolean().describe("Printers from this PC."),
@@ -26609,18 +26627,18 @@ var WebSchema = external_exports.strictObject({
 });
 
 // src/core/schema/vpn.ts
-var VPN_PROVIDERS = ["nordvpn", "openvpn-file"];
+var VPN_PROVIDERS = ["nordvpn", "openvpn-file", "wireguard-file"];
 var VpnSchema = external_exports.strictObject({
   enabled: external_exports.boolean().describe(
     "Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."
   ),
   provider: external_exports.enum(VPN_PROVIDERS).describe(
-    "nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile)."
+    "nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile). wireguard-file: your own WireGuard .conf (configFile), e.g. from your company."
   ),
   protocol: external_exports.enum(["udp", "tcp"]).describe("udp is faster; tcp gets through networks that block udp."),
   country: external_exports.string().regex(/^([A-Za-z][A-Za-z .'-]{0,39})?$/, "a country name or code like uk or Germany").describe("nordvpn: the country of the server, e.g. uk, us or Germany. Empty = the best server anywhere."),
   configFile: external_exports.string().describe(
-    "openvpn-file: the .ovpn file on this PC (its certificates inside it). Files that run programs (script-security, up, down, plugin ...) are refused. A project's file can never set this."
+    "openvpn-file / wireguard-file: the .ovpn or .conf file on this PC (an .ovpn has its certificates inside it). Files that run programs (script-security, up, down, plugin, PostUp ...) are refused. A WireGuard file holds your private key: it is read when a sandbox starts and handed over in a one-shot file. A project's file can never set this."
   ),
   killSwitch: external_exports.boolean().describe(
     "Block all traffic that does not go through the tunnel: when the tunnel cannot start, the sandbox stays offline instead of using your normal connection. A project can only turn this on, never off."
@@ -26647,6 +26665,10 @@ var ConfigSchema = external_exports.strictObject({
     markSandboxFiles: external_exports.boolean().describe(
       `Programs and scripts (.exe, .ps1, .bat, .cmd, .msi, .lnk ...) that appear or change in your project while a sandbox runs get Windows' "downloaded from the internet" mark, so SmartScreen and PowerShell ask before they run on this PC.`
     ),
+    contained: external_exports.enum(["off", "vhdx"]).describe(
+      '(beta) Keep the sandbox tools, state and logs inside one disk image file (vhdx) instead of loose folders, so scanning programs on this PC see one file. Not yet tried on a real PC. Turn it on with sandbox storage contained on (it moves your files and asks first); Windows asks for permission to mount the image when a sandbox starts. "off" = loose folders, as always. Yours only: a project file (.sandbox-config.json) cannot set it.'
+    ),
+    containedMaxGb: external_exports.number().int().min(8).max(4096).describe("(beta) Largest size, in GB, the disk image of storage.contained may grow to."),
     warnDataGb: external_exports.number().min(0).describe(
       "Say at launch when the persisted data (tools, databases, logins) is bigger than this many GB; 0 = never. sandbox data shows what takes the space."
     )
@@ -26690,7 +26712,13 @@ var LocalOverridesSchema = external_exports.strictObject({
     "Scripts (.ps1 / .mjs / .cmd, relative to this file) run inside the sandbox before the agent."
   ),
   // This PC's resources are yours to share: CPU and paging file (this PC's disk) are not a project's to set.
-  sandbox: SandboxSchema.omit({ cpuLimit: true, pageFileMb: true }).partial(),
+  sandbox: SandboxSchema.omit({
+    cpuLimit: true,
+    pageFileMb: true,
+    engine: true,
+    agentMemoryHeadroomMb: true,
+    pressureResponse: true
+  }).partial(),
   // A project may block more (the LAN, hosts); it never opens hosts, ports, DNS or a proxy.
   network: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
   // A project may turn the kill switch on, never off, and never choose a VPN, a server, a file or a login.
@@ -26799,8 +26827,34 @@ var GuestRequestSchema = external_exports.discriminatedUnion("kind", [
     cwd: Text().optional(),
     createdAt: TimeSchema
   }),
-  external_exports.strictObject({ kind: external_exports.literal("ping"), id: IdSchema, createdAt: TimeSchema })
+  external_exports.strictObject({ kind: external_exports.literal("ping"), id: IdSchema, createdAt: TimeSchema }),
+  /**
+   * The PC's own memory or CPU is running low (the host watchdog): the sandbox slows its heaviest builds down for
+   * `seconds` (it never stops them) so Windows does not have to close it. Repeated while the PC stays low.
+   */
+  external_exports.strictObject({
+    kind: external_exports.literal("pressure"),
+    id: IdSchema,
+    reason: Text(300),
+    seconds: external_exports.number().int().min(10).max(300),
+    createdAt: TimeSchema
+  })
 ]);
+var PressureStatusSchema = external_exports.object({
+  level: external_exports.enum(["ok", "throttled", "suspending"]),
+  profile: external_exports.enum(["normal", "gentle"]),
+  /** Share of the sandbox's RAM still free and of its commit limit in use (percent). */
+  ramFreePercent: external_exports.number().int().min(0).max(100),
+  commitPercent: external_exports.number().int().min(0).max(100),
+  /** Programs running at lower priority because of it. */
+  lowered: external_exports.number().int().min(0).max(1024),
+  /** Programs paused right now (name, process id, seconds left). */
+  paused: external_exports.array(external_exports.object({ name: Text(64), pid: external_exports.number().int(), seconds: external_exports.number().int().min(0).max(60) })).max(8),
+  /** The PC itself asked for slowing down (its memory or CPU is low). */
+  pcLow: external_exports.boolean(),
+  lastAction: Text(300),
+  updatedAt: TimeSchema
+});
 var GuestResponseSchema = external_exports.object({
   id: IdSchema,
   ok: external_exports.boolean(),
@@ -27009,6 +27063,8 @@ var RunDir = class {
   root;
   sandboxFile;
   vpnFile;
+  /** What the memory governor in the sandbox is doing (pressure.json). */
+  pressureFile;
   requestsDir;
   responsesDir;
   sessionsDir;
@@ -27021,6 +27077,7 @@ var RunDir = class {
     this.root = path6.join(dataDir2, "run");
     this.sandboxFile = path6.join(this.root, "sandbox.json");
     this.vpnFile = path6.join(this.root, "vpn.json");
+    this.pressureFile = path6.join(this.root, "pressure.json");
     this.requestsDir = path6.join(this.root, "requests");
     this.responsesDir = path6.join(this.root, "responses");
     this.sessionsDir = path6.join(this.root, "sessions");
@@ -27049,6 +27106,9 @@ var RunDir = class {
   readVpnStatus() {
     return readValid(VpnStatusSchema, this.vpnFile);
   }
+  readPressure() {
+    return readValid(PressureStatusSchema, this.pressureFile);
+  }
   readSession(id) {
     return readValid(SessionStatusSchema, this.sessionFile(id));
   }
@@ -27161,6 +27221,7 @@ var SYSTEM = {
   shutdown: () => system32("shutdown.exe"),
   dism: () => system32("Dism.exe"),
   msiexec: () => system32("msiexec.exe"),
+  sc: () => system32("sc.exe"),
   /** The .NET Framework C# compiler that ships with Windows (C# 5). */
   csc: () => path9.join(systemRoot(), "Microsoft.NET", "Framework64", "v4.0.30319", "csc.exe")
 };
@@ -27582,7 +27643,9 @@ var SecretsFileSchema = external_exports.strictObject({
   /** The login of this PC's Claude (claudeProfile.copyCredentials): the text of .credentials.json. */
   claudeCredentials: external_exports.string().max(1024 * 1024).optional(),
   /** VPN service credentials (vpn.provider's login), only for the launch's own sandbox. */
-  vpn: external_exports.strictObject({ username: external_exports.string().min(1).max(256), password: external_exports.string().min(1).max(1024) }).optional()
+  vpn: external_exports.strictObject({ username: external_exports.string().min(1).max(256), password: external_exports.string().min(1).max(1024) }).optional(),
+  /** The checked WireGuard config of vpn.provider wireguard-file (holds the private key). */
+  wireguardConfig: external_exports.string().min(1).max(32 * 1024).optional()
 });
 var withEnvironment = (harness, environment) => environment ? { ...harness, environment: { ...harness.environment, ...environment } } : harness;
 function mergeRequestSecrets(request, secrets) {
@@ -27646,7 +27709,7 @@ function withRequestSecrets(req) {
 }
 
 // src/guest/daemon/daemon.ts
-import fs52 from "node:fs";
+import fs53 from "node:fs";
 
 // src/guest/setup/claude-mem.ts
 import fs14 from "node:fs";
@@ -27958,9 +28021,9 @@ function planPath(input2) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const entry of input2.entries.flatMap(splitPath)) {
-    const key = pathKey(entry);
-    if (seen.has(key) || input2.drop?.(entry) || !input2.exists(entry)) continue;
-    seen.add(key);
+    const key2 = pathKey(entry);
+    if (seen.has(key2) || input2.drop?.(entry) || !input2.exists(entry)) continue;
+    seen.add(key2);
     result.push(entry);
   }
   return result;
@@ -27968,9 +28031,9 @@ function planPath(input2) {
 function appendMissing(base, extra, skip = () => false) {
   const seen = new Set(splitPath(base).map(pathKey));
   const added = splitPath(extra).filter((folder) => {
-    const key = pathKey(folder);
-    if (seen.has(key) || skip(folder)) return false;
-    seen.add(key);
+    const key2 = pathKey(folder);
+    if (seen.has(key2) || skip(folder)) return false;
+    seen.add(key2);
     return true;
   });
   return [...splitPath(base), ...added].join(";");
@@ -27980,9 +28043,9 @@ function parseRegPath(output2) {
   return line ? line.replace(/^\s+Path\s+REG_(EXPAND_)?SZ\s+/i, "").trim() : "";
 }
 function isPinnedNodeDir(folder, nvmHome2) {
-  const key = pathKey(folder);
+  const key2 = pathKey(folder);
   const home = pathKey(nvmHome2);
-  return key.startsWith(home + "\\") && /^v\d/.test(path21.win32.basename(key));
+  return key2.startsWith(home + "\\") && /^v\d/.test(path21.win32.basename(key2));
 }
 
 // src/guest/setup/environment.ts
@@ -28033,7 +28096,7 @@ function addMachineEnvironment(vars, dirs, additive = false) {
 var nvmHome = () => path22.join(toolsDir, "nvm");
 var MACHINE_ENVIRONMENT_KEY = "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment";
 var USER_ENVIRONMENT_KEY = "HKCU\\Environment";
-var registryPath = (key) => parseRegPath(execOutput(SYSTEM.reg(), ["query", key, "/v", "Path"]));
+var registryPath = (key2) => parseRegPath(execOutput(SYSTEM.reg(), ["query", key2, "/v", "Path"]));
 function withRegistryPath(env) {
   if (!isWin || dryRun || testMode) return env;
   try {
@@ -28898,20 +28961,20 @@ var VersionCache = class {
    * the remaining lookups use the remembered versions instead of each waiting for the network; other errors (no such
    * version) do not.
    */
-  async resolve(key, resolve2) {
-    const cached2 = this.remembered()[key];
+  async resolve(key2, resolve2) {
+    const cached2 = this.remembered()[key2];
     if (cached2 && (this.offline || !session.provisioning.refresh && Date.now() - cached2.at < FRESH_MS))
       return cached2.value;
     try {
       const value = await resolve2();
       fs25.mkdirSync(toolsDir, { recursive: true });
-      writeJsonAtomic(this.file(), { ...this.remembered(), [key]: { value, at: Date.now() } });
+      writeJsonAtomic(this.file(), { ...this.remembered(), [key2]: { value, at: Date.now() } });
       return value;
     } catch (e) {
       if (isNetworkError(e)) this.offline = true;
       if (!cached2) throw e;
       warn(
-        "Could not look up the latest " + key + " online (" + errMsg(e) + "); using " + cached2.value + " from an earlier start."
+        "Could not look up the latest " + key2 + " online (" + errMsg(e) + "); using " + cached2.value + " from an earlier start."
       );
       return cached2.value;
     }
@@ -28926,8 +28989,8 @@ var VersionCache = class {
   }
 };
 var versionCache = new VersionCache();
-function resolveCached(key, resolve2) {
-  return versionCache.resolve(key, resolve2);
+function resolveCached(key2, resolve2) {
+  return versionCache.resolve(key2, resolve2);
 }
 
 // src/guest/toolchains/languages/java.ts
@@ -29436,7 +29499,8 @@ var SOURCES = {
   openssl: "OpenSsl.cs",
   cargoshim: "CargoShim.cs",
   linkgate: "LinkGate.cs",
-  pathsync: "PathSync.cs"
+  pathsync: "PathSync.cs",
+  memgov: "MemGov.cs"
 };
 function sourceOf(name) {
   return path40.join(launchDir, "sandbox", "csharp", SOURCES[name]);
@@ -29531,7 +29595,7 @@ var pointAtOwnCertificates = (root) => {
   const bundle = path41.join(root, "mingw64", "etc", "ssl", "certs", "ca-bundle.crt");
   if (!exists(config2) || !exists(bundle)) return;
   const text = fs32.readFileSync(config2, "utf8");
-  const fixed = text.replace(/^(\s*sslCAInfo\s*=\s*).*$/gim, (_m, key) => key + posix(bundle));
+  const fixed = text.replace(/^(\s*sslCAInfo\s*=\s*).*$/gim, (_m, key2) => key2 + posix(bundle));
   if (fixed !== text) fs32.writeFileSync(config2, fixed);
 };
 async function setupGit(env, hostCopy, refresh, access) {
@@ -29703,7 +29767,7 @@ var CLI_TOOLS = [
 ];
 var CLI_NAMES = [...CLI_TOOLS.map((t) => t.name), "openssl"];
 function decideCli(settings, ctx) {
-  const decide = (name) => {
+  const decide2 = (name) => {
     const setting = settings[name] ?? false;
     if (name === "gh" && setting !== false && ctx.gitAccess !== "full")
       return {
@@ -29715,7 +29779,7 @@ function decideCli(settings, ctx) {
     if (name === "openssl") return { on: true, reason: "Git for Windows ships it" };
     return { on: false, reason: "not listed in toolchains.cli" };
   };
-  return Object.fromEntries(CLI_NAMES.map((name) => [name, decide(name)]));
+  return Object.fromEntries(CLI_NAMES.map((name) => [name, decide2(name)]));
 }
 
 // src/guest/toolchains/runtimes.ts
@@ -29998,10 +30062,10 @@ async function setupDotnet(env, config2, refresh) {
       ["global.json:" + fs36.readFileSync(globalJson, "utf8").replace(/\s+/g, ""), ["-JSonFile", globalJson]]
     ] : []
   ];
-  for (const [key, args] of installs.filter(([k]) => !done[k])) {
+  for (const [key2, args] of installs.filter(([k]) => !done[k])) {
     await downloadFile("https://dot.net/v1/dotnet-install.ps1", script);
     log(
-      "Installing the .NET SDK " + (key.startsWith("channel:") ? key.slice(8) : "pinned in global.json") + " (~250 MB once) ..."
+      "Installing the .NET SDK " + (key2.startsWith("channel:") ? key2.slice(8) : "pinned in global.json") + " (~250 MB once) ..."
     );
     await execAsync(SYSTEM.powershell(), [
       "-NoLogo",
@@ -30015,7 +30079,7 @@ async function setupDotnet(env, config2, refresh) {
       root,
       "-NoPath"
     ]);
-    done[key] = true;
+    done[key2] = true;
     writeJsonAtomic(marker, done);
   }
   const home = mkdirp(tool("dotnet-home"));
@@ -30863,7 +30927,7 @@ var phpBuild = async (spec) => {
   );
   const release = Object.values(releases).find((r) => r.version === pick2);
   const build = release && Object.entries(release).find(
-    ([key, value]) => /^nts-vs\d+-x64$/.test(key) && typeof value === "object" && value.zip
+    ([key2, value]) => /^nts-vs\d+-x64$/.test(key2) && typeof value === "object" && value.zip
   )?.[1];
   if (!release || typeof build !== "object" || !build.zip)
     throw new Error('No PHP build for Windows matches "' + spec + '"');
@@ -31210,6 +31274,32 @@ async function setupVscode(env, refresh) {
 import fs47 from "node:fs";
 import os8 from "node:os";
 import path61 from "node:path";
+
+// src/shared/memory/policy.ts
+var GUEST_THRESHOLDS = {
+  normal: {
+    enterAvailablePercent: 8,
+    enterCommitPercent: 92,
+    exitAvailablePercent: 12,
+    exitCommitPercent: 88,
+    calmSamples: 3
+  },
+  gentle: {
+    enterAvailablePercent: 15,
+    enterCommitPercent: 85,
+    exitAvailablePercent: 20,
+    exitCommitPercent: 80,
+    calmSamples: 3
+  }
+};
+function cargoJobs(cpus, memoryGb, sessions2) {
+  const byCpu = Math.max(2, Math.min(4, Math.floor(cpus / 4)));
+  const byMemory = Math.max(1, Math.floor(memoryGb / 4));
+  const jobs = Math.min(byCpu, byMemory);
+  return Math.max(1, Math.min(jobs, Math.floor(8 / Math.max(1, sessions2))));
+}
+
+// src/guest/toolchains/native/rust-extras.ts
 var cargoTarget = (targetDir) => {
   if (targetDir === "shared" || targetDir === "separate") return null;
   if (targetDir === "local") return path61.join(localDir, "cargo-target");
@@ -31244,7 +31334,7 @@ function linkGate(env, rust, host) {
 function cargoDefaults(host) {
   const file3 = tool("rust", "cargo", "config.toml");
   if (exists(file3) || !exists(path61.dirname(file3))) return;
-  const jobs = Math.max(2, Math.min(4, Math.floor(os8.cpus().length / 4)));
+  const jobs = cargoJobs(os8.cpus().length, os8.totalmem() / 1024 ** 3, 1);
   const gnu = host.endsWith("-gnu");
   fs47.writeFileSync(
     file3,
@@ -31524,20 +31614,20 @@ var StepScheduler = class {
   }
   /** Runs `work` once no other step of the same kind (first word of the name) is running. */
   async exclusive(name, work) {
-    const key = name.split(" ")[0].toLowerCase();
-    const previous = this.locks.get(key) ?? Promise.resolve();
+    const key2 = name.split(" ")[0].toLowerCase();
+    const previous = this.locks.get(key2) ?? Promise.resolve();
     let release = () => void 0;
     const mine = new Promise((r) => {
       release = r;
     });
     const chained = previous.then(() => mine);
-    this.locks.set(key, chained);
+    this.locks.set(key2, chained);
     await previous;
     try {
       return await work();
     } finally {
       release();
-      if (this.locks.get(key) === chained) this.locks.delete(key);
+      if (this.locks.get(key2) === chained) this.locks.delete(key2);
     }
   }
 };
@@ -31668,9 +31758,9 @@ var ProjectProvisioner = class {
    */
   provision(spec, say) {
     const id = spec.name.toLowerCase();
-    const key = JSON.stringify(spec);
+    const key2 = JSON.stringify(spec);
     const known = this.running.get(id);
-    if (known && known.key === key) {
+    if (known && known.key === key2) {
       known.listeners.add(say);
       return known.work.finally(() => known.listeners.delete(say));
     }
@@ -31683,7 +31773,7 @@ var ProjectProvisioner = class {
         }
     };
     const work = setUp(spec, broadcast);
-    const entry = { key, work, listeners };
+    const entry = { key: key2, work, listeners };
     this.running.set(id, entry);
     work.then(
       (done) => {
@@ -31729,8 +31819,8 @@ function execCommand(req) {
     { cwd: req.cwd, env, windowsHide: true, windowsVerbatimArguments: true }
   );
   const output2 = { stdout: "", stderr: "" };
-  const collect = (key) => (d) => {
-    if (output2[key].length < MAX_OUTPUT) output2[key] += d;
+  const collect = (key2) => (d) => {
+    if (output2[key2].length < MAX_OUTPUT) output2[key2] += d;
   };
   child.stdout.setEncoding("utf8").on("data", collect("stdout"));
   child.stderr.setEncoding("utf8").on("data", collect("stderr"));
@@ -31754,6 +31844,7 @@ function execCommand(req) {
 // src/guest/daemon/sessions.ts
 import path67 from "node:path";
 import crypto4 from "node:crypto";
+import os11 from "node:os";
 import { spawn as spawn7 } from "node:child_process";
 
 // src/shared/pty/protocol.ts
@@ -31824,6 +31915,9 @@ async function sendControl(endpoint, type) {
   );
 }
 
+// src/shared/pty/output-filter.ts
+var MAX_CLIPBOARD_STRING = 1024 * 1024;
+
 // src/guest/sessions/cmdline.ts
 import path63 from "node:path";
 var quoted = (arg) => '"' + arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1") + '"';
@@ -32075,7 +32169,14 @@ var harnessFor = (req) => {
     'Agent "' + req.harness + '" is not configured for this sandbox (it runs ' + session.harnessName + ")."
   );
 };
-var launchPtyHost = async (req, remote, env, say) => {
+function memoryEnv(env, sessions2) {
+  const out = {};
+  if (session.agentMemoryLimitMb) out.PTYHOST_JOB_MB = String(session.agentMemoryLimitMb);
+  if (!env.CARGO_BUILD_JOBS)
+    out.CARGO_BUILD_JOBS = String(cargoJobs(os11.cpus().length, os11.totalmem() / 1024 ** 3, sessions2));
+  return out;
+}
+var launchPtyHost = async (req, remote, env, say, sessions2) => {
   const harness = harnessFor(req);
   say("Preparing " + req.harness);
   await agents.provision(req.harness, harness, env, false);
@@ -32091,7 +32192,7 @@ var launchPtyHost = async (req, remote, env, say) => {
     rows: 32,
     id: req.id,
     cwd: req.cwd,
-    env: { ...withRegistryPath(env), ...harness.environment },
+    env: { ...withRegistryPath(env), ...harness.environment, ...memoryEnv(env, sessions2) },
     remote,
     command: commandLine(launch.file, [...base, ...req.args]),
     restartCommand: commandLine(launch.file, [...base, ...harness.resumeArguments ?? []])
@@ -32163,7 +32264,7 @@ var SessionManager = class {
     try {
       const place = await placeFor(req, say);
       const remote = session.networking && session.attach.enabled;
-      const { child, port, token } = await launchPtyHost(req, remote, place.env, say);
+      const { child, port, token } = await launchPtyHost(req, remote, place.env, say, this.live.size + 1);
       const resumed = req.harness === "claude" ? resumedConversation(req.args) : void 0;
       const running = {
         ...status,
@@ -32272,6 +32373,335 @@ var SessionManager = class {
 };
 var sessions = new SessionManager();
 
+// src/guest/governor/decide.ts
+var COMPILERS = /* @__PURE__ */ new Set([
+  "rustc",
+  "clippy-driver",
+  "rustdoc",
+  "cc1",
+  "cc1plus",
+  "cc1obj",
+  "collect2",
+  "gcc",
+  "g++",
+  "c++",
+  "cc",
+  "clang",
+  "clang++",
+  "clang-cl",
+  "cl",
+  "link",
+  "lld",
+  "lld-link",
+  "ld",
+  "ld.lld",
+  "as",
+  "tsc",
+  "javac"
+]);
+var BUILD_TOOLS = /* @__PURE__ */ new Set([
+  "node",
+  "dotnet",
+  "msbuild",
+  "vbcscompiler",
+  "ninja",
+  "make",
+  "mingw32-make",
+  "cmake",
+  "cargo",
+  "go",
+  "java",
+  "gradle",
+  "python"
+]);
+var NEVER2 = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+  "aider",
+  "cursor-agent",
+  "cmd",
+  "powershell",
+  "pwsh",
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "conhost",
+  "openconsole",
+  "windowsterminal",
+  "wt",
+  "ptyhost",
+  "memgov",
+  "sandboxtools",
+  "sbx-db",
+  "explorer",
+  "csrss",
+  "wininit",
+  "winlogon",
+  "services",
+  "svchost",
+  "lsass",
+  "system",
+  "smss",
+  "dwm"
+]);
+var key = (name) => name.toLowerCase().replace(/\.exe$/, "");
+var isNeverTouched = (name) => NEVER2.has(key(name));
+var canLower = (name) => !isNeverTouched(name) && (COMPILERS.has(key(name)) || BUILD_TOOLS.has(key(name)));
+var canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
+var INITIAL_STATE = {
+  pressure: false,
+  calm: 0,
+  samples: 0,
+  lowered: {},
+  pausedUntil: 0,
+  nextPauseAt: 0,
+  hostUntil: 0
+};
+var PAUSE_MS = 5e3;
+var PAUSE_COOLDOWN_MS = 1e4;
+var IDLE_AFTER = 3;
+var PAUSE_AFTER = 4;
+var PAUSE_MIN_MB = 300;
+function decide(prev, sample, nowMs, thresholds, profile) {
+  const ramFree = sample.ramAvailMb / Math.max(1, sample.ramTotalMb) * 100;
+  const commit = (sample.commitLimitMb - sample.commitAvailMb) / Math.max(1, sample.commitLimitMb) * 100;
+  const pcLow = nowMs < prev.hostUntil;
+  const low = ramFree < thresholds.enterAvailablePercent || commit > thresholds.enterCommitPercent || pcLow;
+  const recovered = ramFree > thresholds.exitAvailablePercent && commit < thresholds.exitCommitPercent && !pcLow;
+  let pressure = prev.pressure;
+  let calm = prev.calm;
+  let samples = prev.samples;
+  if (low) {
+    pressure = true;
+    calm = 0;
+    samples = prev.samples + 1;
+  } else if (prev.pressure) {
+    calm = recovered ? prev.calm + 1 : 0;
+    if (calm >= thresholds.calmSamples) {
+      pressure = false;
+      calm = 0;
+      samples = 0;
+    }
+  }
+  const actions = [];
+  const present2 = new Set(sample.procs.map((p) => p.pid));
+  const lowered = {};
+  for (const [pid, to] of Object.entries(prev.lowered)) if (present2.has(Number(pid))) lowered[Number(pid)] = to;
+  if (pressure) {
+    const target = samples > IDLE_AFTER ? "idle" : "below";
+    for (const p of sample.procs) {
+      if (!canLower(p.name) || lowered[p.pid] === target) continue;
+      if (p.prio !== target && !(target === "below" && p.prio === "idle"))
+        actions.push({ kind: "priority", pid: p.pid, name: p.name, to: target });
+      lowered[p.pid] = target;
+    }
+  } else {
+    for (const p of sample.procs) {
+      if (!canLower(p.name)) continue;
+      const base = profile === "gentle" && canPause(p.name) ? "below" : "normal";
+      const was = lowered[p.pid];
+      if (prev.pressure && was !== void 0 && was !== base) {
+        if (p.prio !== base) actions.push({ kind: "priority", pid: p.pid, name: p.name, to: base });
+        if (base === "normal") delete lowered[p.pid];
+        else lowered[p.pid] = base;
+      } else if (!prev.pressure && base === "below" && was === void 0) {
+        if (p.prio === "normal") actions.push({ kind: "priority", pid: p.pid, name: p.name, to: "below" });
+        lowered[p.pid] = "below";
+      }
+    }
+  }
+  let pausedUntil = prev.pausedUntil;
+  let nextPauseAt = prev.nextPauseAt;
+  if (pressure && samples >= PAUSE_AFTER && nowMs >= prev.nextPauseAt && nowMs >= prev.pausedUntil) {
+    const victim = [...sample.procs].filter((p) => canPause(p.name) && p.mb >= PAUSE_MIN_MB).sort((a, b) => b.mb - a.mb)[0];
+    if (victim) {
+      actions.push({ kind: "pause", pid: victim.pid, name: victim.name, ms: PAUSE_MS });
+      pausedUntil = nowMs + PAUSE_MS;
+      nextPauseAt = pausedUntil + PAUSE_COOLDOWN_MS;
+    }
+  }
+  const level = nowMs < pausedUntil ? "suspending" : pressure ? "throttled" : "ok";
+  return {
+    state: { pressure, calm, samples, lowered, pausedUntil, nextPauseAt, hostUntil: prev.hostUntil },
+    actions,
+    level,
+    ramFreePercent: Math.round(ramFree),
+    commitPercent: Math.round(commit)
+  };
+}
+
+// src/guest/governor/governor.ts
+import fs52 from "node:fs";
+import path68 from "node:path";
+import { spawn as spawn8 } from "node:child_process";
+import { createInterface } from "node:readline";
+var SampleSchema = external_exports.object({
+  ramTotalMb: external_exports.number(),
+  ramAvailMb: external_exports.number(),
+  commitLimitMb: external_exports.number(),
+  commitAvailMb: external_exports.number(),
+  procs: external_exports.array(
+    external_exports.object({
+      pid: external_exports.number().int(),
+      name: external_exports.string().max(128),
+      mb: external_exports.number(),
+      prio: external_exports.enum(["idle", "below", "normal"]).catch("normal")
+    })
+  ).max(1024)
+});
+var GovernorCore = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  state = INITIAL_STATE;
+  lastAction = "";
+  lastWrite = "";
+  lastWriteAt = 0;
+  pausedName = "";
+  pausedPid = 0;
+  hostPressure(seconds, reason) {
+    const until = this.deps.now() + seconds * 1e3;
+    if (until > this.state.hostUntil) {
+      if (this.state.hostUntil <= this.deps.now())
+        this.deps.logLine("governor: this PC is low (" + reason + "); slowing builds down");
+      this.state = { ...this.state, hostUntil: until };
+    }
+  }
+  get current() {
+    return this.state;
+  }
+  onSample(sample) {
+    const nowMs = this.deps.now();
+    const before = this.state.pressure;
+    const d = decide(this.state, sample, nowMs, GUEST_THRESHOLDS[this.deps.profile], this.deps.profile);
+    this.state = d.state;
+    for (const action of d.actions) this.apply(action);
+    if (d.state.pressure !== before)
+      this.deps.logLine(
+        d.state.pressure ? "governor: memory is low (" + d.ramFreePercent + "% RAM free, commit " + d.commitPercent + "% used): slowing builds down" : "governor: memory is fine again: builds back to normal"
+      );
+    const paused = nowMs < d.state.pausedUntil && this.pausedPid ? [{ name: this.pausedName, pid: this.pausedPid, seconds: Math.ceil((d.state.pausedUntil - nowMs) / 1e3) }] : [];
+    const status = {
+      level: d.level,
+      profile: this.deps.profile,
+      ramFreePercent: Math.max(0, Math.min(100, d.ramFreePercent)),
+      commitPercent: Math.max(0, Math.min(100, d.commitPercent)),
+      lowered: Object.keys(d.state.lowered).length,
+      paused,
+      pcLow: nowMs < d.state.hostUntil,
+      lastAction: this.lastAction,
+      updatedAt: now()
+    };
+    const shape = JSON.stringify({ ...status, updatedAt: "", paused: paused.map((p) => p.pid) });
+    if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 6e4) {
+      this.lastWrite = shape;
+      this.lastWriteAt = nowMs;
+      this.deps.saveStatus(status);
+    }
+  }
+  apply(action) {
+    try {
+      if (action.kind === "priority") {
+        this.deps.port.setPriority(action.pid, action.to);
+        this.lastAction = action.name + " (" + action.pid + ") priority " + action.to;
+      } else {
+        this.deps.port.pause(action.pid, action.ms);
+        this.pausedName = action.name;
+        this.pausedPid = action.pid;
+        this.lastAction = "paused " + action.name + " (" + action.pid + ") for " + action.ms / 1e3 + " s";
+        this.deps.logLine("governor: " + this.lastAction);
+        return;
+      }
+      this.deps.logLine("governor: " + this.lastAction);
+    } catch (e) {
+      warn("governor: " + errMsg(e));
+    }
+  }
+};
+var MemGovProcess = class {
+  constructor(onSample) {
+    this.onSample = onSample;
+  }
+  onSample;
+  child = null;
+  start() {
+    try {
+      const child = spawn8(ensureCompiled("memgov"), ["serve", "--interval", "2"], {
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      this.child = child;
+      createInterface({ input: child.stdout }).on("line", (line) => {
+        try {
+          this.onSample(SampleSchema.parse(JSON.parse(line)));
+        } catch (e) {
+          warn("governor: bad sample: " + errMsg(e));
+        }
+      });
+      child.stdin.on("error", () => void 0);
+      child.once("exit", () => {
+        this.child = null;
+        setTimeout(() => this.start(), 3e4).unref();
+      });
+    } catch (e) {
+      warn("governor: could not start memgov.exe (no memory governor): " + errMsg(e));
+    }
+  }
+  setPriority(pid, to) {
+    this.child?.stdin?.write("priority " + pid + " " + to + "\n");
+  }
+  pause(pid, ms) {
+    this.child?.stdin?.write("suspend " + pid + " " + ms + "\n");
+  }
+};
+function appendToMemoryLog(line) {
+  try {
+    const logs = path68.join(dataDir, "logs");
+    const newest = fs52.readdirSync(logs).filter((f) => /^memory-\d{8}-\d{6}\.log$/.test(f)).sort().pop();
+    if (!newest) return;
+    const t = /* @__PURE__ */ new Date();
+    const stamp = [t.getHours(), t.getMinutes(), t.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+    fs52.appendFileSync(path68.join(logs, newest), stamp + " | " + line + "\r\n");
+  } catch {
+  }
+}
+var Governor = class {
+  core = null;
+  describe() {
+    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
+    const t = GUEST_THRESHOLDS[profile];
+    return session.pressureResponse === false ? "off (sandbox.pressureResponse)" : profile + " profile: slows builds down below " + t.enterAvailablePercent + "% free RAM or above " + t.enterCommitPercent + "% commit";
+  }
+  start() {
+    if (session.pressureResponse === false) return;
+    const profile = session.loadProfile === "gentle" ? "gentle" : "normal";
+    const proc = new MemGovProcess((s) => this.core?.onSample(s));
+    this.core = new GovernorCore({
+      port: proc,
+      profile,
+      now: () => Date.now(),
+      logLine: appendToMemoryLog,
+      saveStatus: (status) => {
+        try {
+          writeJsonAtomic(run.pressureFile, status);
+        } catch (e) {
+          warn("governor: could not write its status: " + errMsg(e));
+        }
+      }
+    });
+    proc.start();
+  }
+  /** The host's watchdog: this PC is low for a while. */
+  hostPressure(seconds, reason) {
+    this.core?.hostPressure(seconds, reason);
+  }
+};
+var governor = new Governor();
+
 // src/guest/daemon/daemon.ts
 var POLL_MS = 400;
 var MEM_SAVE_MS = 12e4;
@@ -32290,9 +32720,9 @@ var Daemon = class {
   tick() {
     const { valid, invalid } = run.scanRequests();
     for (const file3 of invalid)
-      safely("removing an invalid request", () => fs52.rmSync(file3, { recursive: true, force: true }));
+      safely("removing an invalid request", () => fs53.rmSync(file3, { recursive: true, force: true }));
     for (const req of valid) {
-      safely("claiming a request", () => fs52.rmSync(run.requestFile(req.id), { force: true }));
+      safely("claiming a request", () => fs53.rmSync(run.requestFile(req.id), { force: true }));
       if (run.readSession(req.id)) continue;
       void Promise.resolve(this.handle(withRequestSecrets(req))).catch(
         (e) => respond(req.id, { ok: false, message: errMsg(e) })
@@ -32314,6 +32744,8 @@ var Daemon = class {
         return execCommand(req);
       case "restart":
         return sessions.restart(req);
+      case "pressure":
+        return governor.hostPressure(req.seconds, req.reason);
       case "ping":
         return respond(req.id, { ok: true, message: "pong (" + sessions.count + " session(s) running)" });
     }
@@ -32327,4 +32759,6 @@ adoptBootSecrets();
 log("Session daemon started (pid " + process.pid + ").");
 safely("port forwards", startRelays);
 safely("audit", startProcessCollector);
+safely("memory governor", () => governor.start());
+log("Memory governor: " + governor.describe());
 new Daemon().start();