openclaw-telegram-manager 2.9.0 → 2.10.0

package/dist/plugin.js

@@ -86,14 +86,14 @@ var require_polyfills = __commonJS({
       fs14.fstatSync = statFixSync(fs14.fstatSync);
       fs14.lstatSync = statFixSync(fs14.lstatSync);
       if (fs14.chmod && !fs14.lchmod) {
-        fs14.lchmod = function(path15, mode, cb) {
+        fs14.lchmod = function(path16, mode, cb) {
           if (cb) process.nextTick(cb);
         };
         fs14.lchmodSync = function() {
         };
       }
       if (fs14.chown && !fs14.lchown) {
-        fs14.lchown = function(path15, uid, gid, cb) {
+        fs14.lchown = function(path16, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
         fs14.lchownSync = function() {
@@ -160,9 +160,9 @@ var require_polyfills = __commonJS({
         };
       })(fs14.readSync);
       function patchLchmod(fs15) {
-        fs15.lchmod = function(path15, mode, callback) {
+        fs15.lchmod = function(path16, mode, callback) {
           fs15.open(
-            path15,
+            path16,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -178,8 +178,8 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs15.lchmodSync = function(path15, mode) {
-          var fd = fs15.openSync(path15, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs15.lchmodSync = function(path16, mode) {
+          var fd = fs15.openSync(path16, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -200,8 +200,8 @@ var require_polyfills = __commonJS({
       }
       function patchLutimes(fs15) {
         if (constants.hasOwnProperty("O_SYMLINK") && fs15.futimes) {
-          fs15.lutimes = function(path15, at, mt, cb) {
-            fs15.open(path15, constants.O_SYMLINK, function(er, fd) {
+          fs15.lutimes = function(path16, at, mt, cb) {
+            fs15.open(path16, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -213,8 +213,8 @@ var require_polyfills = __commonJS({
               });
             });
           };
-          fs15.lutimesSync = function(path15, at, mt) {
-            var fd = fs15.openSync(path15, constants.O_SYMLINK);
+          fs15.lutimesSync = function(path16, at, mt) {
+            var fd = fs15.openSync(path16, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -332,11 +332,11 @@ var require_legacy_streams = __commonJS({
         ReadStream,
         WriteStream
       };
-      function ReadStream(path15, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
+      function ReadStream(path16, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path16, options);
         Stream.call(this);
         var self = this;
-        this.path = path15;
+        this.path = path16;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -381,10 +381,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path15, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
+      function WriteStream(path16, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path16, options);
         Stream.call(this);
-        this.path = path15;
+        this.path = path16;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -527,14 +527,14 @@ var require_graceful_fs = __commonJS({
       fs15.createWriteStream = createWriteStream;
       var fs$readFile = fs15.readFile;
       fs15.readFile = readFile;
-      function readFile(path15, options, cb) {
+      function readFile(path16, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path15, options, cb);
-        function go$readFile(path16, options2, cb2, startTime) {
-          return fs$readFile(path16, options2, function(err) {
+        return go$readFile(path16, options, cb);
+        function go$readFile(path17, options2, cb2, startTime) {
+          return fs$readFile(path17, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path16, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -544,14 +544,14 @@ var require_graceful_fs = __commonJS({
       }
       var fs$writeFile = fs15.writeFile;
       fs15.writeFile = writeFile;
-      function writeFile(path15, data, options, cb) {
+      function writeFile(path16, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path15, data, options, cb);
-        function go$writeFile(path16, data2, options2, cb2, startTime) {
-          return fs$writeFile(path16, data2, options2, function(err) {
+        return go$writeFile(path16, data, options, cb);
+        function go$writeFile(path17, data2, options2, cb2, startTime) {
+          return fs$writeFile(path17, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -562,14 +562,14 @@ var require_graceful_fs = __commonJS({
       var fs$appendFile = fs15.appendFile;
       if (fs$appendFile)
         fs15.appendFile = appendFile;
-      function appendFile(path15, data, options, cb) {
+      function appendFile(path16, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path15, data, options, cb);
-        function go$appendFile(path16, data2, options2, cb2, startTime) {
-          return fs$appendFile(path16, data2, options2, function(err) {
+        return go$appendFile(path16, data, options, cb);
+        function go$appendFile(path17, data2, options2, cb2, startTime) {
+          return fs$appendFile(path17, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -600,31 +600,31 @@ var require_graceful_fs = __commonJS({
       var fs$readdir = fs15.readdir;
       fs15.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path15, options, cb) {
+      function readdir(path16, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path16, options2, cb2, startTime) {
-          return fs$readdir(path16, fs$readdirCallback(
-            path16,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, fs$readdirCallback(
+            path17,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path16, options2, cb2, startTime) {
-          return fs$readdir(path16, options2, fs$readdirCallback(
-            path16,
+        } : function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, options2, fs$readdirCallback(
+            path17,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path15, options, cb);
-        function fs$readdirCallback(path16, options2, cb2, startTime) {
+        return go$readdir(path16, options, cb);
+        function fs$readdirCallback(path17, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path16, options2, cb2],
+                [path17, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -695,7 +695,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path15, options) {
+      function ReadStream(path16, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -715,7 +715,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path15, options) {
+      function WriteStream(path16, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -733,22 +733,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path15, options) {
-        return new fs15.ReadStream(path15, options);
+      function createReadStream(path16, options) {
+        return new fs15.ReadStream(path16, options);
       }
-      function createWriteStream(path15, options) {
-        return new fs15.WriteStream(path15, options);
+      function createWriteStream(path16, options) {
+        return new fs15.WriteStream(path16, options);
       }
       var fs$open = fs15.open;
       fs15.open = open;
-      function open(path15, flags, mode, cb) {
+      function open(path16, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path15, flags, mode, cb);
-        function go$open(path16, flags2, mode2, cb2, startTime) {
-          return fs$open(path16, flags2, mode2, function(err, fd) {
+        return go$open(path16, flags, mode, cb);
+        function go$open(path17, flags2, mode2, cb2, startTime) {
+          return fs$open(path17, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path16, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1277,7 +1277,7 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path15 = __require("path");
+    var path16 = __require("path");
     var fs14 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
@@ -1288,7 +1288,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path15.resolve(file));
+        return callback(null, path16.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -2725,7 +2725,7 @@ var require_lib = __commonJS({
 
 // src/index.ts
 import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
@@ -6298,32 +6298,32 @@ var ValueErrorIterator = class {
     return next.done ? void 0 : next.value;
   }
 };
-function Create(errorType, schema, path15, value, errors = []) {
+function Create(errorType, schema, path16, value, errors = []) {
   return {
     type: errorType,
     schema,
-    path: path15,
+    path: path16,
     value,
-    message: GetErrorFunction()({ errorType, path: path15, schema, value, errors }),
+    message: GetErrorFunction()({ errorType, path: path16, schema, value, errors }),
     errors
   };
 }
-function* FromAny3(schema, references, path15, value) {
+function* FromAny3(schema, references, path16, value) {
 }
-function* FromArgument3(schema, references, path15, value) {
+function* FromArgument3(schema, references, path16, value) {
 }
-function* FromArray8(schema, references, path15, value) {
+function* FromArray8(schema, references, path16, value) {
   if (!IsArray2(value)) {
-    return yield Create(ValueErrorType.Array, schema, path15, value);
+    return yield Create(ValueErrorType.Array, schema, path16, value);
   }
   if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield Create(ValueErrorType.ArrayMinItems, schema, path15, value);
+    yield Create(ValueErrorType.ArrayMinItems, schema, path16, value);
   }
   if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield Create(ValueErrorType.ArrayMaxItems, schema, path15, value);
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path16, value);
   }
   for (let i = 0; i < value.length; i++) {
-    yield* Visit6(schema.items, references, `${path15}/${i}`, value[i]);
+    yield* Visit6(schema.items, references, `${path16}/${i}`, value[i]);
   }
   if (schema.uniqueItems === true && !(function() {
     const set = /* @__PURE__ */ new Set();
@@ -6337,116 +6337,116 @@ function* FromArray8(schema, references, path15, value) {
     }
     return true;
   })()) {
-    yield Create(ValueErrorType.ArrayUniqueItems, schema, path15, value);
+    yield Create(ValueErrorType.ArrayUniqueItems, schema, path16, value);
   }
   if (!(IsDefined2(schema.contains) || IsDefined2(schema.minContains) || IsDefined2(schema.maxContains))) {
     return;
   }
   const containsSchema = IsDefined2(schema.contains) ? schema.contains : Never();
-  const containsCount = value.reduce((acc, value2, index) => Visit6(containsSchema, references, `${path15}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+  const containsCount = value.reduce((acc, value2, index) => Visit6(containsSchema, references, `${path16}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
   if (containsCount === 0) {
-    yield Create(ValueErrorType.ArrayContains, schema, path15, value);
+    yield Create(ValueErrorType.ArrayContains, schema, path16, value);
   }
   if (IsNumber2(schema.minContains) && containsCount < schema.minContains) {
-    yield Create(ValueErrorType.ArrayMinContains, schema, path15, value);
+    yield Create(ValueErrorType.ArrayMinContains, schema, path16, value);
   }
   if (IsNumber2(schema.maxContains) && containsCount > schema.maxContains) {
-    yield Create(ValueErrorType.ArrayMaxContains, schema, path15, value);
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path16, value);
   }
 }
-function* FromAsyncIterator5(schema, references, path15, value) {
+function* FromAsyncIterator5(schema, references, path16, value) {
   if (!IsAsyncIterator2(value))
-    yield Create(ValueErrorType.AsyncIterator, schema, path15, value);
+    yield Create(ValueErrorType.AsyncIterator, schema, path16, value);
 }
-function* FromBigInt3(schema, references, path15, value) {
+function* FromBigInt3(schema, references, path16, value) {
   if (!IsBigInt2(value))
-    return yield Create(ValueErrorType.BigInt, schema, path15, value);
+    return yield Create(ValueErrorType.BigInt, schema, path16, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path15, value);
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path15, value);
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.BigIntMaximum, schema, path15, value);
+    yield Create(ValueErrorType.BigIntMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.BigIntMinimum, schema, path15, value);
+    yield Create(ValueErrorType.BigIntMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield Create(ValueErrorType.BigIntMultipleOf, schema, path15, value);
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path16, value);
   }
 }
-function* FromBoolean3(schema, references, path15, value) {
+function* FromBoolean3(schema, references, path16, value) {
   if (!IsBoolean2(value))
-    yield Create(ValueErrorType.Boolean, schema, path15, value);
+    yield Create(ValueErrorType.Boolean, schema, path16, value);
 }
-function* FromConstructor5(schema, references, path15, value) {
-  yield* Visit6(schema.returns, references, path15, value.prototype);
+function* FromConstructor5(schema, references, path16, value) {
+  yield* Visit6(schema.returns, references, path16, value.prototype);
 }
-function* FromDate3(schema, references, path15, value) {
+function* FromDate3(schema, references, path16, value) {
   if (!IsDate2(value))
-    return yield Create(ValueErrorType.Date, schema, path15, value);
+    return yield Create(ValueErrorType.Date, schema, path16, value);
   if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path15, value);
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path16, value);
   }
   if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path15, value);
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path16, value);
   }
   if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path15, value);
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path16, value);
   }
   if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path15, value);
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path16, value);
   }
   if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path15, value);
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path16, value);
   }
 }
-function* FromFunction5(schema, references, path15, value) {
+function* FromFunction5(schema, references, path16, value) {
   if (!IsFunction2(value))
-    yield Create(ValueErrorType.Function, schema, path15, value);
+    yield Create(ValueErrorType.Function, schema, path16, value);
 }
-function* FromImport2(schema, references, path15, value) {
+function* FromImport2(schema, references, path16, value) {
   const definitions = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  yield* Visit6(target, [...references, ...definitions], path15, value);
+  yield* Visit6(target, [...references, ...definitions], path16, value);
 }
-function* FromInteger3(schema, references, path15, value) {
+function* FromInteger3(schema, references, path16, value) {
   if (!IsInteger(value))
-    return yield Create(ValueErrorType.Integer, schema, path15, value);
+    return yield Create(ValueErrorType.Integer, schema, path16, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path15, value);
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path15, value);
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.IntegerMaximum, schema, path15, value);
+    yield Create(ValueErrorType.IntegerMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.IntegerMinimum, schema, path15, value);
+    yield Create(ValueErrorType.IntegerMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.IntegerMultipleOf, schema, path15, value);
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path16, value);
   }
 }
-function* FromIntersect10(schema, references, path15, value) {
+function* FromIntersect10(schema, references, path16, value) {
   let hasError = false;
   for (const inner of schema.allOf) {
-    for (const error of Visit6(inner, references, path15, value)) {
+    for (const error of Visit6(inner, references, path16, value)) {
       hasError = true;
       yield error;
     }
   }
   if (hasError) {
-    return yield Create(ValueErrorType.Intersect, schema, path15, value);
+    return yield Create(ValueErrorType.Intersect, schema, path16, value);
   }
   if (schema.unevaluatedProperties === false) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path15}/${valueKey}`, value);
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path16}/${valueKey}`, value);
       }
     }
   }
@@ -6454,59 +6454,59 @@ function* FromIntersect10(schema, references, path15, value) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        const next = Visit6(schema.unevaluatedProperties, references, `${path15}/${valueKey}`, value[valueKey]).next();
+        const next = Visit6(schema.unevaluatedProperties, references, `${path16}/${valueKey}`, value[valueKey]).next();
         if (!next.done)
           yield next.value;
       }
     }
   }
 }
-function* FromIterator5(schema, references, path15, value) {
+function* FromIterator5(schema, references, path16, value) {
   if (!IsIterator2(value))
-    yield Create(ValueErrorType.Iterator, schema, path15, value);
+    yield Create(ValueErrorType.Iterator, schema, path16, value);
 }
-function* FromLiteral4(schema, references, path15, value) {
+function* FromLiteral4(schema, references, path16, value) {
   if (!(value === schema.const))
-    yield Create(ValueErrorType.Literal, schema, path15, value);
+    yield Create(ValueErrorType.Literal, schema, path16, value);
 }
-function* FromNever3(schema, references, path15, value) {
-  yield Create(ValueErrorType.Never, schema, path15, value);
+function* FromNever3(schema, references, path16, value) {
+  yield Create(ValueErrorType.Never, schema, path16, value);
 }
-function* FromNot3(schema, references, path15, value) {
-  if (Visit6(schema.not, references, path15, value).next().done === true)
-    yield Create(ValueErrorType.Not, schema, path15, value);
+function* FromNot3(schema, references, path16, value) {
+  if (Visit6(schema.not, references, path16, value).next().done === true)
+    yield Create(ValueErrorType.Not, schema, path16, value);
 }
-function* FromNull3(schema, references, path15, value) {
+function* FromNull3(schema, references, path16, value) {
   if (!IsNull2(value))
-    yield Create(ValueErrorType.Null, schema, path15, value);
+    yield Create(ValueErrorType.Null, schema, path16, value);
 }
-function* FromNumber3(schema, references, path15, value) {
+function* FromNumber3(schema, references, path16, value) {
   if (!TypeSystemPolicy.IsNumberLike(value))
-    return yield Create(ValueErrorType.Number, schema, path15, value);
+    return yield Create(ValueErrorType.Number, schema, path16, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path15, value);
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path15, value);
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.NumberMaximum, schema, path15, value);
+    yield Create(ValueErrorType.NumberMaximum, schema, path16, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.NumberMinimum, schema, path15, value);
+    yield Create(ValueErrorType.NumberMinimum, schema, path16, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.NumberMultipleOf, schema, path15, value);
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path16, value);
   }
 }
-function* FromObject9(schema, references, path15, value) {
+function* FromObject9(schema, references, path16, value) {
   if (!TypeSystemPolicy.IsObjectLike(value))
-    return yield Create(ValueErrorType.Object, schema, path15, value);
+    return yield Create(ValueErrorType.Object, schema, path16, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path16, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path15, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path16, value);
   }
   const requiredKeys = Array.isArray(schema.required) ? schema.required : [];
   const knownKeys = Object.getOwnPropertyNames(schema.properties);
@@ -6514,12 +6514,12 @@ function* FromObject9(schema, references, path15, value) {
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey))
       continue;
-    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path15}/${EscapeKey(requiredKey)}`, void 0);
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path16}/${EscapeKey(requiredKey)}`, void 0);
   }
   if (schema.additionalProperties === false) {
     for (const valueKey of unknownKeys) {
       if (!knownKeys.includes(valueKey)) {
-        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path15}/${EscapeKey(valueKey)}`, value[valueKey]);
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path16}/${EscapeKey(valueKey)}`, value[valueKey]);
       }
     }
   }
@@ -6527,235 +6527,235 @@ function* FromObject9(schema, references, path15, value) {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey))
         continue;
-      yield* Visit6(schema.additionalProperties, references, `${path15}/${EscapeKey(valueKey)}`, value[valueKey]);
+      yield* Visit6(schema.additionalProperties, references, `${path16}/${EscapeKey(valueKey)}`, value[valueKey]);
     }
   }
   for (const knownKey of knownKeys) {
     const property = schema.properties[knownKey];
     if (schema.required && schema.required.includes(knownKey)) {
-      yield* Visit6(property, references, `${path15}/${EscapeKey(knownKey)}`, value[knownKey]);
+      yield* Visit6(property, references, `${path16}/${EscapeKey(knownKey)}`, value[knownKey]);
       if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
-        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path15}/${EscapeKey(knownKey)}`, void 0);
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path16}/${EscapeKey(knownKey)}`, void 0);
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit6(property, references, `${path15}/${EscapeKey(knownKey)}`, value[knownKey]);
+        yield* Visit6(property, references, `${path16}/${EscapeKey(knownKey)}`, value[knownKey]);
       }
     }
   }
 }
-function* FromPromise5(schema, references, path15, value) {
+function* FromPromise5(schema, references, path16, value) {
   if (!IsPromise(value))
-    yield Create(ValueErrorType.Promise, schema, path15, value);
+    yield Create(ValueErrorType.Promise, schema, path16, value);
 }
-function* FromRecord5(schema, references, path15, value) {
+function* FromRecord5(schema, references, path16, value) {
   if (!TypeSystemPolicy.IsRecordLike(value))
-    return yield Create(ValueErrorType.Object, schema, path15, value);
+    return yield Create(ValueErrorType.Object, schema, path16, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path16, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path15, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path16, value);
   }
   const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
   const regex = new RegExp(patternKey);
   for (const [propertyKey, propertyValue] of Object.entries(value)) {
     if (regex.test(propertyKey))
-      yield* Visit6(patternSchema, references, `${path15}/${EscapeKey(propertyKey)}`, propertyValue);
+      yield* Visit6(patternSchema, references, `${path16}/${EscapeKey(propertyKey)}`, propertyValue);
   }
   if (typeof schema.additionalProperties === "object") {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
       if (!regex.test(propertyKey))
-        yield* Visit6(schema.additionalProperties, references, `${path15}/${EscapeKey(propertyKey)}`, propertyValue);
+        yield* Visit6(schema.additionalProperties, references, `${path16}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
   if (schema.additionalProperties === false) {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
       if (regex.test(propertyKey))
         continue;
-      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path15}/${EscapeKey(propertyKey)}`, propertyValue);
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path16}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
 }
-function* FromRef6(schema, references, path15, value) {
-  yield* Visit6(Deref(schema, references), references, path15, value);
+function* FromRef6(schema, references, path16, value) {
+  yield* Visit6(Deref(schema, references), references, path16, value);
 }
-function* FromRegExp3(schema, references, path15, value) {
+function* FromRegExp3(schema, references, path16, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path15, value);
+    return yield Create(ValueErrorType.String, schema, path16, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path16, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path15, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path16, value);
   }
   const regex = new RegExp(schema.source, schema.flags);
   if (!regex.test(value)) {
-    return yield Create(ValueErrorType.RegExp, schema, path15, value);
+    return yield Create(ValueErrorType.RegExp, schema, path16, value);
   }
 }
-function* FromString3(schema, references, path15, value) {
+function* FromString3(schema, references, path16, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path15, value);
+    return yield Create(ValueErrorType.String, schema, path16, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path16, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path15, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path16, value);
   }
   if (IsString2(schema.pattern)) {
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
-      yield Create(ValueErrorType.StringPattern, schema, path15, value);
+      yield Create(ValueErrorType.StringPattern, schema, path16, value);
     }
   }
   if (IsString2(schema.format)) {
     if (!format_exports.Has(schema.format)) {
-      yield Create(ValueErrorType.StringFormatUnknown, schema, path15, value);
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path16, value);
     } else {
       const format = format_exports.Get(schema.format);
       if (!format(value)) {
-        yield Create(ValueErrorType.StringFormat, schema, path15, value);
+        yield Create(ValueErrorType.StringFormat, schema, path16, value);
       }
     }
   }
 }
-function* FromSymbol3(schema, references, path15, value) {
+function* FromSymbol3(schema, references, path16, value) {
   if (!IsSymbol2(value))
-    yield Create(ValueErrorType.Symbol, schema, path15, value);
+    yield Create(ValueErrorType.Symbol, schema, path16, value);
 }
-function* FromTemplateLiteral5(schema, references, path15, value) {
+function* FromTemplateLiteral5(schema, references, path16, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path15, value);
+    return yield Create(ValueErrorType.String, schema, path16, value);
   const regex = new RegExp(schema.pattern);
   if (!regex.test(value)) {
-    yield Create(ValueErrorType.StringPattern, schema, path15, value);
+    yield Create(ValueErrorType.StringPattern, schema, path16, value);
   }
 }
-function* FromThis2(schema, references, path15, value) {
-  yield* Visit6(Deref(schema, references), references, path15, value);
+function* FromThis2(schema, references, path16, value) {
+  yield* Visit6(Deref(schema, references), references, path16, value);
 }
-function* FromTuple7(schema, references, path15, value) {
+function* FromTuple7(schema, references, path16, value) {
   if (!IsArray2(value))
-    return yield Create(ValueErrorType.Tuple, schema, path15, value);
+    return yield Create(ValueErrorType.Tuple, schema, path16, value);
   if (schema.items === void 0 && !(value.length === 0)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path15, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path16, value);
   }
   if (!(value.length === schema.maxItems)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path15, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path16, value);
   }
   if (!schema.items) {
     return;
   }
   for (let i = 0; i < schema.items.length; i++) {
-    yield* Visit6(schema.items[i], references, `${path15}/${i}`, value[i]);
+    yield* Visit6(schema.items[i], references, `${path16}/${i}`, value[i]);
   }
 }
-function* FromUndefined3(schema, references, path15, value) {
+function* FromUndefined3(schema, references, path16, value) {
   if (!IsUndefined2(value))
-    yield Create(ValueErrorType.Undefined, schema, path15, value);
+    yield Create(ValueErrorType.Undefined, schema, path16, value);
 }
-function* FromUnion12(schema, references, path15, value) {
+function* FromUnion12(schema, references, path16, value) {
   if (Check(schema, references, value))
     return;
-  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path15, value)));
-  yield Create(ValueErrorType.Union, schema, path15, value, errors);
+  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path16, value)));
+  yield Create(ValueErrorType.Union, schema, path16, value, errors);
 }
-function* FromUint8Array3(schema, references, path15, value) {
+function* FromUint8Array3(schema, references, path16, value) {
   if (!IsUint8Array2(value))
-    return yield Create(ValueErrorType.Uint8Array, schema, path15, value);
+    return yield Create(ValueErrorType.Uint8Array, schema, path16, value);
   if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path15, value);
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path16, value);
   }
   if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path15, value);
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path16, value);
   }
 }
-function* FromUnknown3(schema, references, path15, value) {
+function* FromUnknown3(schema, references, path16, value) {
 }
-function* FromVoid3(schema, references, path15, value) {
+function* FromVoid3(schema, references, path16, value) {
   if (!TypeSystemPolicy.IsVoidLike(value))
-    yield Create(ValueErrorType.Void, schema, path15, value);
+    yield Create(ValueErrorType.Void, schema, path16, value);
 }
-function* FromKind2(schema, references, path15, value) {
+function* FromKind2(schema, references, path16, value) {
   const check2 = type_exports2.Get(schema[Kind]);
   if (!check2(schema, value))
-    yield Create(ValueErrorType.Kind, schema, path15, value);
+    yield Create(ValueErrorType.Kind, schema, path16, value);
 }
-function* Visit6(schema, references, path15, value) {
+function* Visit6(schema, references, path16, value) {
   const references_ = IsDefined2(schema.$id) ? [...references, schema] : references;
   const schema_ = schema;
   switch (schema_[Kind]) {
     case "Any":
-      return yield* FromAny3(schema_, references_, path15, value);
+      return yield* FromAny3(schema_, references_, path16, value);
     case "Argument":
-      return yield* FromArgument3(schema_, references_, path15, value);
+      return yield* FromArgument3(schema_, references_, path16, value);
     case "Array":
-      return yield* FromArray8(schema_, references_, path15, value);
+      return yield* FromArray8(schema_, references_, path16, value);
     case "AsyncIterator":
-      return yield* FromAsyncIterator5(schema_, references_, path15, value);
+      return yield* FromAsyncIterator5(schema_, references_, path16, value);
     case "BigInt":
-      return yield* FromBigInt3(schema_, references_, path15, value);
+      return yield* FromBigInt3(schema_, references_, path16, value);
     case "Boolean":
-      return yield* FromBoolean3(schema_, references_, path15, value);
+      return yield* FromBoolean3(schema_, references_, path16, value);
     case "Constructor":
-      return yield* FromConstructor5(schema_, references_, path15, value);
+      return yield* FromConstructor5(schema_, references_, path16, value);
     case "Date":
-      return yield* FromDate3(schema_, references_, path15, value);
+      return yield* FromDate3(schema_, references_, path16, value);
     case "Function":
-      return yield* FromFunction5(schema_, references_, path15, value);
+      return yield* FromFunction5(schema_, references_, path16, value);
     case "Import":
-      return yield* FromImport2(schema_, references_, path15, value);
+      return yield* FromImport2(schema_, references_, path16, value);
     case "Integer":
-      return yield* FromInteger3(schema_, references_, path15, value);
+      return yield* FromInteger3(schema_, references_, path16, value);
     case "Intersect":
-      return yield* FromIntersect10(schema_, references_, path15, value);
+      return yield* FromIntersect10(schema_, references_, path16, value);
     case "Iterator":
-      return yield* FromIterator5(schema_, references_, path15, value);
+      return yield* FromIterator5(schema_, references_, path16, value);
     case "Literal":
-      return yield* FromLiteral4(schema_, references_, path15, value);
+      return yield* FromLiteral4(schema_, references_, path16, value);
     case "Never":
-      return yield* FromNever3(schema_, references_, path15, value);
+      return yield* FromNever3(schema_, references_, path16, value);
     case "Not":
-      return yield* FromNot3(schema_, references_, path15, value);
+      return yield* FromNot3(schema_, references_, path16, value);
     case "Null":
-      return yield* FromNull3(schema_, references_, path15, value);
+      return yield* FromNull3(schema_, references_, path16, value);
     case "Number":
-      return yield* FromNumber3(schema_, references_, path15, value);
+      return yield* FromNumber3(schema_, references_, path16, value);
     case "Object":
-      return yield* FromObject9(schema_, references_, path15, value);
+      return yield* FromObject9(schema_, references_, path16, value);
     case "Promise":
-      return yield* FromPromise5(schema_, references_, path15, value);
+      return yield* FromPromise5(schema_, references_, path16, value);
     case "Record":
-      return yield* FromRecord5(schema_, references_, path15, value);
+      return yield* FromRecord5(schema_, references_, path16, value);
     case "Ref":
-      return yield* FromRef6(schema_, references_, path15, value);
+      return yield* FromRef6(schema_, references_, path16, value);
     case "RegExp":
-      return yield* FromRegExp3(schema_, references_, path15, value);
+      return yield* FromRegExp3(schema_, references_, path16, value);
     case "String":
-      return yield* FromString3(schema_, references_, path15, value);
+      return yield* FromString3(schema_, references_, path16, value);
     case "Symbol":
-      return yield* FromSymbol3(schema_, references_, path15, value);
+      return yield* FromSymbol3(schema_, references_, path16, value);
     case "TemplateLiteral":
-      return yield* FromTemplateLiteral5(schema_, references_, path15, value);
+      return yield* FromTemplateLiteral5(schema_, references_, path16, value);
     case "This":
-      return yield* FromThis2(schema_, references_, path15, value);
+      return yield* FromThis2(schema_, references_, path16, value);
     case "Tuple":
-      return yield* FromTuple7(schema_, references_, path15, value);
+      return yield* FromTuple7(schema_, references_, path16, value);
     case "Undefined":
-      return yield* FromUndefined3(schema_, references_, path15, value);
+      return yield* FromUndefined3(schema_, references_, path16, value);
     case "Union":
-      return yield* FromUnion12(schema_, references_, path15, value);
+      return yield* FromUnion12(schema_, references_, path16, value);
     case "Uint8Array":
-      return yield* FromUint8Array3(schema_, references_, path15, value);
+      return yield* FromUint8Array3(schema_, references_, path16, value);
     case "Unknown":
-      return yield* FromUnknown3(schema_, references_, path15, value);
+      return yield* FromUnknown3(schema_, references_, path16, value);
     case "Void":
-      return yield* FromVoid3(schema_, references_, path15, value);
+      return yield* FromVoid3(schema_, references_, path16, value);
     default:
       if (!type_exports2.Has(schema_[Kind]))
         throw new ValueErrorsUnknownTypeError(schema);
-      return yield* FromKind2(schema_, references_, path15, value);
+      return yield* FromKind2(schema_, references_, path16, value);
   }
 }
 function Errors(...args) {
@@ -7797,58 +7797,58 @@ var TransformDecodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformDecodeError = class extends TypeBoxError {
-  constructor(schema, path15, value, error) {
+  constructor(schema, path16, value, error) {
     super(error instanceof Error ? error.message : "Unknown error");
     this.schema = schema;
-    this.path = path15;
+    this.path = path16;
     this.value = value;
     this.error = error;
   }
 };
-function Default3(schema, path15, value) {
+function Default3(schema, path16, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
-    throw new TransformDecodeError(schema, path15, value, error);
+    throw new TransformDecodeError(schema, path16, value, error);
   }
 }
-function FromArray14(schema, references, path15, value) {
-  return IsArray2(value) ? Default3(schema, path15, value.map((value2, index) => Visit11(schema.items, references, `${path15}/${index}`, value2))) : Default3(schema, path15, value);
+function FromArray14(schema, references, path16, value) {
+  return IsArray2(value) ? Default3(schema, path16, value.map((value2, index) => Visit11(schema.items, references, `${path16}/${index}`, value2))) : Default3(schema, path16, value);
 }
-function FromIntersect15(schema, references, path15, value) {
+function FromIntersect15(schema, references, path16, value) {
   if (!IsObject2(value) || IsValueType(value))
-    return Default3(schema, path15, value);
+    return Default3(schema, path16, value);
   const knownEntries = KeyOfPropertyEntries(schema);
   const knownKeys = knownEntries.map((entry) => entry[0]);
   const knownProperties = { ...value };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit11(knownSchema, references, `${path15}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit11(knownSchema, references, `${path16}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default3(schema, path15, knownProperties);
+    return Default3(schema, path16, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const unevaluatedProperties = schema.unevaluatedProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default3(unevaluatedProperties, `${path15}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(unevaluatedProperties, `${path16}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path15, unknownProperties);
+  return Default3(schema, path16, unknownProperties);
 }
-function FromImport7(schema, references, path15, value) {
+function FromImport7(schema, references, path16, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Visit11(target, [...references, ...additional], path15, value);
-  return Default3(schema, path15, result);
+  const result = Visit11(target, [...references, ...additional], path16, value);
+  return Default3(schema, path16, result);
 }
-function FromNot5(schema, references, path15, value) {
-  return Default3(schema, path15, Visit11(schema.not, references, path15, value));
+function FromNot5(schema, references, path16, value) {
+  return Default3(schema, path16, Visit11(schema.not, references, path16, value));
 }
-function FromObject15(schema, references, path15, value) {
+function FromObject15(schema, references, path16, value) {
   if (!IsObject2(value))
-    return Default3(schema, path15, value);
+    return Default3(schema, path16, value);
   const knownKeys = KeyOfPropertyKeys(schema);
   const knownProperties = { ...value };
   for (const key of knownKeys) {
@@ -7856,90 +7856,90 @@ function FromObject15(schema, references, path15, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit11(schema.properties[key], references, `${path15}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit11(schema.properties[key], references, `${path16}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path15, knownProperties);
+    return Default3(schema, path16, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const additionalProperties = schema.additionalProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default3(additionalProperties, `${path15}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path16}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path15, unknownProperties);
+  return Default3(schema, path16, unknownProperties);
 }
-function FromRecord10(schema, references, path15, value) {
+function FromRecord10(schema, references, path16, value) {
   if (!IsObject2(value))
-    return Default3(schema, path15, value);
+    return Default3(schema, path16, value);
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
   const knownKeys = new RegExp(pattern);
   const knownProperties = { ...value };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path15}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path16}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path15, knownProperties);
+    return Default3(schema, path16, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const additionalProperties = schema.additionalProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      unknownProperties[key] = Default3(additionalProperties, `${path15}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path16}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path15, unknownProperties);
+  return Default3(schema, path16, unknownProperties);
 }
-function FromRef11(schema, references, path15, value) {
+function FromRef11(schema, references, path16, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path15, Visit11(target, references, path15, value));
+  return Default3(schema, path16, Visit11(target, references, path16, value));
 }
-function FromThis7(schema, references, path15, value) {
+function FromThis7(schema, references, path16, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path15, Visit11(target, references, path15, value));
+  return Default3(schema, path16, Visit11(target, references, path16, value));
 }
-function FromTuple12(schema, references, path15, value) {
-  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path15, schema.items.map((schema2, index) => Visit11(schema2, references, `${path15}/${index}`, value[index]))) : Default3(schema, path15, value);
+function FromTuple12(schema, references, path16, value) {
+  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path16, schema.items.map((schema2, index) => Visit11(schema2, references, `${path16}/${index}`, value[index]))) : Default3(schema, path16, value);
 }
-function FromUnion17(schema, references, path15, value) {
+function FromUnion17(schema, references, path16, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const decoded = Visit11(subschema, references, path15, value);
-    return Default3(schema, path15, decoded);
+    const decoded = Visit11(subschema, references, path16, value);
+    return Default3(schema, path16, decoded);
   }
-  return Default3(schema, path15, value);
+  return Default3(schema, path16, value);
 }
-function Visit11(schema, references, path15, value) {
+function Visit11(schema, references, path16, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray14(schema_, references_, path15, value);
+      return FromArray14(schema_, references_, path16, value);
     case "Import":
-      return FromImport7(schema_, references_, path15, value);
+      return FromImport7(schema_, references_, path16, value);
     case "Intersect":
-      return FromIntersect15(schema_, references_, path15, value);
+      return FromIntersect15(schema_, references_, path16, value);
     case "Not":
-      return FromNot5(schema_, references_, path15, value);
+      return FromNot5(schema_, references_, path16, value);
     case "Object":
-      return FromObject15(schema_, references_, path15, value);
+      return FromObject15(schema_, references_, path16, value);
     case "Record":
-      return FromRecord10(schema_, references_, path15, value);
+      return FromRecord10(schema_, references_, path16, value);
     case "Ref":
-      return FromRef11(schema_, references_, path15, value);
+      return FromRef11(schema_, references_, path16, value);
     case "Symbol":
-      return Default3(schema_, path15, value);
+      return Default3(schema_, path16, value);
     case "This":
-      return FromThis7(schema_, references_, path15, value);
+      return FromThis7(schema_, references_, path16, value);
     case "Tuple":
-      return FromTuple12(schema_, references_, path15, value);
+      return FromTuple12(schema_, references_, path16, value);
     case "Union":
-      return FromUnion17(schema_, references_, path15, value);
+      return FromUnion17(schema_, references_, path16, value);
     default:
-      return Default3(schema_, path15, value);
+      return Default3(schema_, path16, value);
   }
 }
 function TransformDecode(schema, references, value) {
@@ -7956,33 +7956,33 @@ var TransformEncodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformEncodeError = class extends TypeBoxError {
-  constructor(schema, path15, value, error) {
+  constructor(schema, path16, value, error) {
     super(`${error instanceof Error ? error.message : "Unknown error"}`);
     this.schema = schema;
-    this.path = path15;
+    this.path = path16;
     this.value = value;
     this.error = error;
   }
 };
-function Default4(schema, path15, value) {
+function Default4(schema, path16, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
-    throw new TransformEncodeError(schema, path15, value, error);
+    throw new TransformEncodeError(schema, path16, value, error);
   }
 }
-function FromArray15(schema, references, path15, value) {
-  const defaulted = Default4(schema, path15, value);
-  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path15}/${index}`, value2)) : defaulted;
+function FromArray15(schema, references, path16, value) {
+  const defaulted = Default4(schema, path16, value);
+  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path16}/${index}`, value2)) : defaulted;
 }
-function FromImport8(schema, references, path15, value) {
+function FromImport8(schema, references, path16, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Default4(schema, path15, value);
-  return Visit12(target, [...references, ...additional], path15, result);
+  const result = Default4(schema, path16, value);
+  return Visit12(target, [...references, ...additional], path16, result);
 }
-function FromIntersect16(schema, references, path15, value) {
-  const defaulted = Default4(schema, path15, value);
+function FromIntersect16(schema, references, path16, value) {
+  const defaulted = Default4(schema, path16, value);
   if (!IsObject2(value) || IsValueType(value))
     return defaulted;
   const knownEntries = KeyOfPropertyEntries(schema);
@@ -7990,7 +7990,7 @@ function FromIntersect16(schema, references, path15, value) {
   const knownProperties = { ...defaulted };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit12(knownSchema, references, `${path15}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit12(knownSchema, references, `${path16}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return knownProperties;
@@ -8000,15 +8000,15 @@ function FromIntersect16(schema, references, path15, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(unevaluatedProperties, `${path15}/${key}`, properties[key]);
+      properties[key] = Default4(unevaluatedProperties, `${path16}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot6(schema, references, path15, value) {
-  return Default4(schema.not, path15, Default4(schema, path15, value));
+function FromNot6(schema, references, path16, value) {
+  return Default4(schema.not, path16, Default4(schema, path16, value));
 }
-function FromObject16(schema, references, path15, value) {
-  const defaulted = Default4(schema, path15, value);
+function FromObject16(schema, references, path16, value) {
+  const defaulted = Default4(schema, path16, value);
   if (!IsObject2(defaulted))
     return defaulted;
   const knownKeys = KeyOfPropertyKeys(schema);
@@ -8018,7 +8018,7 @@ function FromObject16(schema, references, path15, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit12(schema.properties[key], references, `${path15}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit12(schema.properties[key], references, `${path16}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8028,12 +8028,12 @@ function FromObject16(schema, references, path15, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(additionalProperties, `${path15}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path16}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord11(schema, references, path15, value) {
-  const defaulted = Default4(schema, path15, value);
+function FromRecord11(schema, references, path16, value) {
+  const defaulted = Default4(schema, path16, value);
   if (!IsObject2(value))
     return defaulted;
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -8041,7 +8041,7 @@ function FromRecord11(schema, references, path15, value) {
   const knownProperties = { ...defaulted };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path15}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path16}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8051,65 +8051,65 @@ function FromRecord11(schema, references, path15, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      properties[key] = Default4(additionalProperties, `${path15}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path16}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef12(schema, references, path15, value) {
+function FromRef12(schema, references, path16, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path15, value);
-  return Default4(schema, path15, resolved);
+  const resolved = Visit12(target, references, path16, value);
+  return Default4(schema, path16, resolved);
 }
-function FromThis8(schema, references, path15, value) {
+function FromThis8(schema, references, path16, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path15, value);
-  return Default4(schema, path15, resolved);
+  const resolved = Visit12(target, references, path16, value);
+  return Default4(schema, path16, resolved);
 }
-function FromTuple13(schema, references, path15, value) {
-  const value1 = Default4(schema, path15, value);
-  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path15}/${index}`, value1[index])) : [];
+function FromTuple13(schema, references, path16, value) {
+  const value1 = Default4(schema, path16, value);
+  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path16}/${index}`, value1[index])) : [];
 }
-function FromUnion18(schema, references, path15, value) {
+function FromUnion18(schema, references, path16, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const value1 = Visit12(subschema, references, path15, value);
-    return Default4(schema, path15, value1);
+    const value1 = Visit12(subschema, references, path16, value);
+    return Default4(schema, path16, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit12(subschema, references, path15, value);
+    const value1 = Visit12(subschema, references, path16, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default4(schema, path15, value1);
+    return Default4(schema, path16, value1);
   }
-  return Default4(schema, path15, value);
+  return Default4(schema, path16, value);
 }
-function Visit12(schema, references, path15, value) {
+function Visit12(schema, references, path16, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray15(schema_, references_, path15, value);
+      return FromArray15(schema_, references_, path16, value);
     case "Import":
-      return FromImport8(schema_, references_, path15, value);
+      return FromImport8(schema_, references_, path16, value);
     case "Intersect":
-      return FromIntersect16(schema_, references_, path15, value);
+      return FromIntersect16(schema_, references_, path16, value);
     case "Not":
-      return FromNot6(schema_, references_, path15, value);
+      return FromNot6(schema_, references_, path16, value);
     case "Object":
-      return FromObject16(schema_, references_, path15, value);
+      return FromObject16(schema_, references_, path16, value);
     case "Record":
-      return FromRecord11(schema_, references_, path15, value);
+      return FromRecord11(schema_, references_, path16, value);
     case "Ref":
-      return FromRef12(schema_, references_, path15, value);
+      return FromRef12(schema_, references_, path16, value);
     case "This":
-      return FromThis8(schema_, references_, path15, value);
+      return FromThis8(schema_, references_, path16, value);
     case "Tuple":
-      return FromTuple13(schema_, references_, path15, value);
+      return FromTuple13(schema_, references_, path16, value);
     case "Union":
-      return FromUnion18(schema_, references_, path15, value);
+      return FromUnion18(schema_, references_, path16, value);
     default:
-      return Default4(schema_, path15, value);
+      return Default4(schema_, path16, value);
   }
 }
 function TransformEncode(schema, references, value) {
@@ -8377,18 +8377,18 @@ __export(pointer_exports, {
   ValuePointerRootSetError: () => ValuePointerRootSetError
 });
 var ValuePointerRootSetError = class extends TypeBoxError {
-  constructor(value, path15, update) {
+  constructor(value, path16, update) {
     super("Cannot set root value");
     this.value = value;
-    this.path = path15;
+    this.path = path16;
     this.update = update;
   }
 };
 var ValuePointerRootDeleteError = class extends TypeBoxError {
-  constructor(value, path15) {
+  constructor(value, path16) {
     super("Cannot delete root value");
     this.value = value;
-    this.path = path15;
+    this.path = path16;
   }
 };
 function Escape2(component) {
@@ -8532,82 +8532,82 @@ var ValueDiffError = class extends TypeBoxError {
     this.value = value;
   }
 };
-function CreateUpdate(path15, value) {
-  return { type: "update", path: path15, value };
+function CreateUpdate(path16, value) {
+  return { type: "update", path: path16, value };
 }
-function CreateInsert(path15, value) {
-  return { type: "insert", path: path15, value };
+function CreateInsert(path16, value) {
+  return { type: "insert", path: path16, value };
 }
-function CreateDelete(path15) {
-  return { type: "delete", path: path15 };
+function CreateDelete(path16) {
+  return { type: "delete", path: path16 };
 }
 function AssertDiffable(value) {
   if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
     throw new ValueDiffError(value, "Cannot diff objects with symbols");
 }
-function* ObjectType4(path15, current, next) {
+function* ObjectType4(path16, current, next) {
   AssertDiffable(current);
   AssertDiffable(next);
   if (!IsStandardObject(next))
-    return yield CreateUpdate(path15, next);
+    return yield CreateUpdate(path16, next);
   const currentKeys = globalThis.Object.getOwnPropertyNames(current);
   const nextKeys = globalThis.Object.getOwnPropertyNames(next);
   for (const key of nextKeys) {
     if (HasPropertyKey2(current, key))
       continue;
-    yield CreateInsert(`${path15}/${key}`, next[key]);
+    yield CreateInsert(`${path16}/${key}`, next[key]);
   }
   for (const key of currentKeys) {
     if (!HasPropertyKey2(next, key))
       continue;
     if (Equal(current, next))
       continue;
-    yield* Visit15(`${path15}/${key}`, current[key], next[key]);
+    yield* Visit15(`${path16}/${key}`, current[key], next[key]);
   }
   for (const key of currentKeys) {
     if (HasPropertyKey2(next, key))
       continue;
-    yield CreateDelete(`${path15}/${key}`);
+    yield CreateDelete(`${path16}/${key}`);
   }
 }
-function* ArrayType4(path15, current, next) {
+function* ArrayType4(path16, current, next) {
   if (!IsArray2(next))
-    return yield CreateUpdate(path15, next);
+    return yield CreateUpdate(path16, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path15}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path16}/${i}`, current[i], next[i]);
   }
   for (let i = 0; i < next.length; i++) {
     if (i < current.length)
       continue;
-    yield CreateInsert(`${path15}/${i}`, next[i]);
+    yield CreateInsert(`${path16}/${i}`, next[i]);
   }
   for (let i = current.length - 1; i >= 0; i--) {
     if (i < next.length)
       continue;
-    yield CreateDelete(`${path15}/${i}`);
+    yield CreateDelete(`${path16}/${i}`);
   }
 }
-function* TypedArrayType2(path15, current, next) {
+function* TypedArrayType2(path16, current, next) {
   if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-    return yield CreateUpdate(path15, next);
+    return yield CreateUpdate(path16, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path15}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path16}/${i}`, current[i], next[i]);
   }
 }
-function* ValueType2(path15, current, next) {
+function* ValueType2(path16, current, next) {
   if (current === next)
     return;
-  yield CreateUpdate(path15, next);
+  yield CreateUpdate(path16, next);
 }
-function* Visit15(path15, current, next) {
+function* Visit15(path16, current, next) {
   if (IsStandardObject(current))
-    return yield* ObjectType4(path15, current, next);
+    return yield* ObjectType4(path16, current, next);
   if (IsArray2(current))
-    return yield* ArrayType4(path15, current, next);
+    return yield* ArrayType4(path16, current, next);
   if (IsTypedArray(current))
-    return yield* TypedArrayType2(path15, current, next);
+    return yield* TypedArrayType2(path16, current, next);
   if (IsValueType(current))
-    return yield* ValueType2(path15, current, next);
+    return yield* ValueType2(path16, current, next);
   throw new ValueDiffError(current, "Unable to diff value");
 }
 function Diff(current, next) {
@@ -8664,9 +8664,9 @@ var ValueMutateError = class extends TypeBoxError {
     super(message);
   }
 };
-function ObjectType5(root, path15, current, next) {
+function ObjectType5(root, path16, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path15, Clone2(next));
+    pointer_exports.Set(root, path16, Clone2(next));
   } else {
     const currentKeys = Object.getOwnPropertyNames(current);
     const nextKeys = Object.getOwnPropertyNames(next);
@@ -8681,43 +8681,43 @@ function ObjectType5(root, path15, current, next) {
       }
     }
     for (const nextKey of nextKeys) {
-      Visit16(root, `${path15}/${nextKey}`, current[nextKey], next[nextKey]);
+      Visit16(root, `${path16}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
-function ArrayType5(root, path15, current, next) {
+function ArrayType5(root, path16, current, next) {
   if (!IsArray2(current)) {
-    pointer_exports.Set(root, path15, Clone2(next));
+    pointer_exports.Set(root, path16, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path15}/${index}`, current[index], next[index]);
+      Visit16(root, `${path16}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
-function TypedArrayType3(root, path15, current, next) {
+function TypedArrayType3(root, path16, current, next) {
   if (IsTypedArray(current) && current.length === next.length) {
     for (let i = 0; i < current.length; i++) {
       current[i] = next[i];
     }
   } else {
-    pointer_exports.Set(root, path15, Clone2(next));
+    pointer_exports.Set(root, path16, Clone2(next));
   }
 }
-function ValueType3(root, path15, current, next) {
+function ValueType3(root, path16, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path15, next);
+  pointer_exports.Set(root, path16, next);
 }
-function Visit16(root, path15, current, next) {
+function Visit16(root, path16, current, next) {
   if (IsArray2(next))
-    return ArrayType5(root, path15, current, next);
+    return ArrayType5(root, path16, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path15, current, next);
+    return TypedArrayType3(root, path16, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path15, current, next);
+    return ObjectType5(root, path16, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path15, current, next);
+    return ValueType3(root, path16, current, next);
 }
 function IsNonMutableValue(value) {
   return IsTypedArray(value) || IsValueType(value);
@@ -8815,11 +8815,11 @@ __export(value_exports2, {
 });
 
 // src/lib/types.ts
-var CURRENT_REGISTRY_VERSION = 6;
+var CURRENT_REGISTRY_VERSION = 7;
 var CAPSULE_VERSION = 4;
 var MAX_POST_ERROR_LENGTH = 500;
 var MAX_NAME_LENGTH = 100;
-var DOCTOR_ALL_COOLDOWN_MS = 60 * 60 * 1e3;
+var DOCTOR_ALL_COOLDOWN_MS = 20 * 60 * 60 * 1e3;
 var DOCTOR_PER_TOPIC_CAP_MS = 24 * 60 * 60 * 1e3;
 var INACTIVE_AFTER_DAYS = 7;
 var SPAM_THRESHOLD = 3;
@@ -8863,6 +8863,7 @@ var RegistrySchema = Type.Object({
   topicManagerAdmins: Type.Array(Type.String()),
   callbackSecret: Type.String(),
   lastDoctorAllRunAt: Type.Union([Type.String(), Type.Null()]),
+  dailyReportCronJobId: Type.Union([Type.String(), Type.Null()]),
   autopilotEnabled: Type.Boolean(),
   maxTopics: Type.Integer({ minimum: 1 }),
   topics: Type.Record(Type.String(), TopicEntrySchema)
@@ -8943,6 +8944,12 @@ var migrations = {
       }
     }
     return data;
+  },
+  "6_to_7": (data) => {
+    if (data["dailyReportCronJobId"] === void 0) {
+      data["dailyReportCronJobId"] = null;
+    }
+    return data;
   }
 };
 function migrateRegistry(data) {
@@ -9298,6 +9305,8 @@ var AuthTier = {
 var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
   "doctor --all",
   "doctor-all",
+  "daily-report --all",
+  "daily-report-all",
   "list",
   "sync",
   "rename",
@@ -9517,8 +9526,9 @@ function buildHelpCard() {
     "/tm doctor \u2014 run health checks",
     "/tm doctor --all \u2014 check all topics at once",
     "/tm daily-report \u2014 post a daily summary",
-    "/tm autopilot enable \u2014 automatic daily health checks",
-    "/tm autopilot disable \u2014 turn off automatic checks",
+    "/tm daily-report --all \u2014 post daily summaries for all topics",
+    "/tm autopilot enable \u2014 automatic daily reports and health checks",
+    "/tm autopilot disable \u2014 turn off automatic reports and checks",
     "",
     "**Manage topics**",
     "/tm rename new-name \u2014 rename this topic",
@@ -9867,20 +9877,22 @@ async function getConfigWrites(rpc) {
   }
 }
 
+// src/commands/autopilot.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+
 // src/lib/cron.ts
 var DEFAULT_CRON_SCHEDULE = "0 9 * * *";
 var DEFAULT_CRON_TZ = "UTC";
-async function registerDailyReportCron(rpc, params, logger) {
+async function registerCombinedCron(rpc, logger, schedule, tz) {
   if (!rpc) {
     return { jobId: null, error: "RPC not available" };
   }
-  const { topicName, slug, groupId, threadId, schedule, tz } = params;
   const cronExpr = schedule ?? DEFAULT_CRON_SCHEDULE;
   const timezone = tz ?? DEFAULT_CRON_TZ;
-  const telegramTarget = `${groupId}:topic:${threadId}`;
   try {
     const result = await rpc.call("cron.add", {
-      name: `tm-daily-${slug}`,
+      name: "tm-daily-combined",
       schedule: {
         kind: "cron",
         expr: cronExpr,
@@ -9890,26 +9902,18 @@ async function registerDailyReportCron(rpc, params, logger) {
       wakeMode: "now",
       payload: {
         kind: "agentTurn",
-        message: `Run topic_manager with command "daily-report" for the topic "${topicName}" (slug: ${slug}, group: ${groupId}, thread: ${threadId}). Post the report to this topic.`
-      },
-      delivery: {
-        mode: "announce",
-        channels: {
-          telegram: {
-            to: telegramTarget
-          }
-        }
+        message: 'Run topic_manager with command "daily-report --all" to post daily reports for all eligible topics. Then run topic_manager with command "doctor --all" to health-check all active topics.'
       }
     });
     const jobId = result["jobId"] ?? result["id"] ?? null;
     if (jobId) {
-      logger.info(`[cron] Created daily report job "${jobId}" for ${slug} (${cronExpr} ${timezone})`);
+      logger.info(`[cron] Created combined daily job "${jobId}" (${cronExpr} ${timezone})`);
       return { jobId };
     }
     return { jobId: null, error: "Gateway did not return a job ID" };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    logger.error(`[cron] Failed to create daily report job for ${slug}: ${msg}`);
+    logger.error(`[cron] Failed to create combined daily job: ${msg}`);
     return { jobId: null, error: msg };
   }
 }
@@ -9929,20 +9933,13 @@ async function removeCronJob(rpc, jobId, logger) {
 }
 
 // src/commands/autopilot.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
 var MARKER_START = "<!-- TM_AUTOPILOT_START -->";
 var MARKER_END = "<!-- TM_AUTOPILOT_END -->";
 var HEARTBEAT_BLOCK = `${MARKER_START}
 ## Topic Manager \u2014 Balanced Autopilot
 
-Execute these steps IN ORDER. Do not skip steps.
-
-1. CALL \`topic_manager\` with command "doctor --all" to health-check all active topics.
-   This runs health checks AND posts daily progress reports for each eligible topic automatically.
-2. For each topic where STATUS.md "Last done (UTC)" is >3 days old:
-   post a brief nudge in that topic asking the user for a status update.
-3. If no actions were taken in steps 1-2, do nothing (HEARTBEAT_OK).
+Daily reports and health checks are handled by the cron scheduler.
+No action needed here (HEARTBEAT_OK).
 ${MARKER_END}`;
 var HEARTBEAT_FILENAME = "HEARTBEAT.md";
 async function handleAutopilot(ctx, args) {
@@ -9968,7 +9965,7 @@ async function handleAutopilot(ctx, args) {
   }
 }
 async function handleEnable(ctx) {
-  const { workspaceDir } = ctx;
+  const { workspaceDir, rpc, logger } = ctx;
   const heartbeatPath = path6.join(workspaceDir, HEARTBEAT_FILENAME);
   let content = "";
   try {
@@ -9981,6 +9978,7 @@ async function handleEnable(ctx) {
     await withRegistry(workspaceDir, (data) => {
       data.autopilotEnabled = true;
     });
+    await ensureCombinedCron(workspaceDir, rpc, logger);
     return { text: "Autopilot is already enabled." };
   }
   const newContent = content ? content.trimEnd() + "\n\n" + HEARTBEAT_BLOCK + "\n" : HEARTBEAT_BLOCK + "\n";
@@ -9988,14 +9986,17 @@ async function handleEnable(ctx) {
   await withRegistry(workspaceDir, (data) => {
     data.autopilotEnabled = true;
   });
+  await ensureCombinedCron(workspaceDir, rpc, logger);
+  await cleanupPerTopicCrons(workspaceDir, rpc, logger);
   return {
-    text: "**Autopilot enabled.**\nHealth checks will run automatically every day."
+    text: "**Autopilot enabled.**\nDaily reports and health checks will run automatically at 09:00 UTC."
   };
 }
 async function handleDisable(ctx) {
-  const { workspaceDir } = ctx;
+  const { workspaceDir, rpc, logger } = ctx;
   const heartbeatPath = path6.join(workspaceDir, HEARTBEAT_FILENAME);
   if (!fs6.existsSync(heartbeatPath)) {
+    await removeCombinedCron(workspaceDir, rpc, logger);
     await withRegistry(workspaceDir, (data) => {
       data.autopilotEnabled = false;
     });
@@ -10003,6 +10004,7 @@ async function handleDisable(ctx) {
   }
   let content = fs6.readFileSync(heartbeatPath, "utf-8");
   if (!content.includes(MARKER_START)) {
+    await removeCombinedCron(workspaceDir, rpc, logger);
     await withRegistry(workspaceDir, (data) => {
       data.autopilotEnabled = false;
     });
@@ -10020,11 +10022,12 @@ async function handleDisable(ctx) {
       fs6.unlinkSync(heartbeatPath);
     }
   }
+  await removeCombinedCron(workspaceDir, rpc, logger);
   await withRegistry(workspaceDir, (data) => {
     data.autopilotEnabled = false;
   });
   return {
-    text: "**Autopilot disabled.**\nAutomatic health checks are now off."
+    text: "**Autopilot disabled.**\nAutomatic daily reports and health checks are now off."
   };
 }
 async function handleStatus(ctx) {
@@ -10032,14 +10035,52 @@ async function handleStatus(ctx) {
   const registry = readRegistry(workspaceDir);
   const enabled = registry.autopilotEnabled;
   const lastRun = registry.lastDoctorAllRunAt ? relativeTime(registry.lastDoctorAllRunAt) : "never";
+  const cronStatus = registry.dailyReportCronJobId ? "active (09:00 UTC)" : "not registered";
   const lines = [
     `**Autopilot:** ${enabled ? "enabled" : "disabled"}`,
+    `**Daily cron:** ${cronStatus}`,
     `**Last health check run:** ${lastRun}`
   ];
   return {
     text: lines.join("\n")
   };
 }
+async function ensureCombinedCron(workspaceDir, rpc, logger) {
+  const registry = readRegistry(workspaceDir);
+  if (registry.dailyReportCronJobId) return;
+  const result = await registerCombinedCron(rpc, logger);
+  if (result.jobId) {
+    await withRegistry(workspaceDir, (data) => {
+      data.dailyReportCronJobId = result.jobId;
+    });
+  }
+}
+async function removeCombinedCron(workspaceDir, rpc, logger) {
+  const registry = readRegistry(workspaceDir);
+  if (!registry.dailyReportCronJobId) return;
+  await removeCronJob(rpc, registry.dailyReportCronJobId, logger);
+  await withRegistry(workspaceDir, (data) => {
+    data.dailyReportCronJobId = null;
+  });
+}
+async function cleanupPerTopicCrons(workspaceDir, rpc, logger) {
+  const registry = readRegistry(workspaceDir);
+  const topicsWithCron = Object.entries(registry.topics).filter(([, entry]) => entry.cronJobId !== null);
+  if (topicsWithCron.length === 0) return;
+  for (const [, entry] of topicsWithCron) {
+    if (entry.cronJobId) {
+      await removeCronJob(rpc, entry.cronJobId, logger);
+    }
+  }
+  await withRegistry(workspaceDir, (data) => {
+    for (const [key] of topicsWithCron) {
+      const entry = data.topics[key];
+      if (entry) {
+        entry.cronJobId = null;
+      }
+    }
+  });
+}
 
 // src/commands/init.ts
 var VALID_TYPES = /* @__PURE__ */ new Set(["coding", "research", "marketing", "general"]);
@@ -10181,25 +10222,6 @@ async function handleInit(ctx, args) {
     restartMsg = `
 Warning: config sync failed: ${msg}`;
   }
-  try {
-    const cronResult = await registerDailyReportCron(rpc, {
-      topicName: name,
-      slug: finalSlug,
-      groupId,
-      threadId
-    }, logger);
-    if (cronResult.jobId) {
-      await withRegistry(workspaceDir, (data) => {
-        const entry = data.topics[key];
-        if (entry) {
-          entry.cronJobId = cronResult.jobId;
-        }
-      });
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.error(`[init] Cron registration failed: ${msg}`);
-  }
   appendAudit(
     workspaceDir,
     buildAuditEntry(userId, "init", finalSlug, `Initialized topic name="${name}" type=${topicType} group=${groupId} thread=${threadId}`)
@@ -10646,6 +10668,15 @@ async function handleDoctor(ctx) {
   if (!entry) {
     return { text: "This topic is not registered. Run /tm init first." };
   }
+  if (entry.lastDoctorReportAt) {
+    const elapsed = Date.now() - new Date(entry.lastDoctorReportAt).getTime();
+    if (elapsed < DOCTOR_PER_TOPIC_CAP_MS) {
+      const remainingHrs = Math.ceil((DOCTOR_PER_TOPIC_CAP_MS - elapsed) / 36e5);
+      return {
+        text: `This topic was checked recently. Next health check available in ~${remainingHrs} hour(s).`
+      };
+    }
+  }
   const projectsBase = path9.join(workspaceDir, "projects");
   if (!jailCheck(projectsBase, entry.slug)) {
     return { text: "Something went wrong \u2014 path validation failed." };
@@ -11473,35 +11504,6 @@ async function handleArchiveToggle(ctx, archive) {
       }
     }
   });
-  if (archive && entry.cronJobId) {
-    await removeCronJob(rpc, entry.cronJobId, logger);
-    await withRegistry(workspaceDir, (data) => {
-      const topic = data.topics[key];
-      if (topic) {
-        topic.cronJobId = null;
-      }
-    });
-  } else if (!archive && !entry.cronJobId) {
-    try {
-      const cronResult = await registerDailyReportCron(rpc, {
-        topicName: entry.name,
-        slug: entry.slug,
-        groupId,
-        threadId
-      }, logger);
-      if (cronResult.jobId) {
-        await withRegistry(workspaceDir, (data) => {
-          const topic = data.topics[key];
-          if (topic) {
-            topic.cronJobId = cronResult.jobId;
-          }
-        });
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger.error(`[archive] Cron re-registration failed: ${msg}`);
-    }
-  }
   let restartMsg = "";
   try {
     const updatedRegistry = readRegistry(workspaceDir);
@@ -11528,6 +11530,243 @@ Warning: config sync failed: ${msg}`;
   };
 }
 
+// src/commands/daily-report-all.ts
+import * as path14 from "node:path";
+function getDailyReportEligibility(entry, now, statusTimestamp) {
+  if (entry.status === "archived") return { eligible: false, skipReason: "archived" };
+  if (entry.snoozeUntil && new Date(entry.snoozeUntil).getTime() > now.getTime()) {
+    return { eligible: false, skipReason: "snoozed" };
+  }
+  const lastActive = mostRecent(entry.lastMessageAt, statusTimestamp);
+  if (lastActive) {
+    const lastActiveMs = new Date(lastActive).getTime();
+    const inactiveMs = INACTIVE_AFTER_DAYS * 24 * 60 * 60 * 1e3;
+    if (now.getTime() - lastActiveMs > inactiveMs) {
+      return { eligible: false, skipReason: "inactive" };
+    }
+  }
+  if (entry.lastDailyReportAt) {
+    const lastReport = new Date(entry.lastDailyReportAt);
+    if (lastReport.getUTCFullYear() === now.getUTCFullYear() && lastReport.getUTCMonth() === now.getUTCMonth() && lastReport.getUTCDate() === now.getUTCDate()) {
+      return { eligible: false, skipReason: "already-reported-today" };
+    }
+  }
+  return { eligible: true };
+}
+var SKIP_ICONS2 = {
+  archived: "\u{1F4E6}",
+  // 📦
+  snoozed: "\u{1F4A4}",
+  // 💤
+  inactive: "\u{1F507}",
+  // 🔇
+  "already-reported-today": "\u23F0"
+  // ⏰
+};
+var SKIP_LABELS2 = {
+  archived: "archived",
+  snoozed: "snoozed",
+  inactive: "inactive",
+  "already-reported-today": "already reported today"
+};
+var SUMMARY_SOFT_LIMIT2 = 3800;
+function buildDailyReportAllSummary(data) {
+  const {
+    reportedTopics,
+    skippedTopics,
+    postFailures,
+    migrationGroups,
+    errors
+  } = data;
+  if (reportedTopics.length === 0 && skippedTopics.length === 0) {
+    return "**Daily Report Summary**\n\nNo topics registered yet.";
+  }
+  const lines = ["**Daily Report Summary**", ""];
+  let renderedCount = 0;
+  for (const t of reportedTopics) {
+    let icon;
+    let label;
+    switch (t.status) {
+      case "reported":
+        icon = "\u2705";
+        label = "reported";
+        break;
+      case "post-failed":
+        icon = "\u26A0\uFE0F";
+        label = "failed to post";
+        break;
+    }
+    const line = `${icon} ${t.name} \u2014 ${label}`;
+    if (lines.join("\n").length + line.length > SUMMARY_SOFT_LIMIT2) {
+      const remaining = reportedTopics.length - renderedCount;
+      lines.push(`... and ${remaining} more`);
+      break;
+    }
+    lines.push(line);
+    renderedCount++;
+  }
+  if (skippedTopics.length > 0) {
+    lines.push("");
+    lines.push("\u23ED\uFE0F Skipped:");
+    let skippedRendered = 0;
+    for (const t of skippedTopics) {
+      const icon = SKIP_ICONS2[t.reason];
+      const label = SKIP_LABELS2[t.reason];
+      const line = `${icon} ${t.name} \u2014 ${label}`;
+      if (lines.join("\n").length + line.length > SUMMARY_SOFT_LIMIT2) {
+        const remaining = skippedTopics.length - skippedRendered;
+        lines.push(`... and ${remaining} more`);
+        break;
+      }
+      lines.push(line);
+      skippedRendered++;
+    }
+  }
+  if (postFailures > 0) {
+    lines.push("");
+    lines.push(`\u26A0\uFE0F ${postFailures} topic(s) failed to post`);
+  }
+  if (migrationGroups > 0) {
+    lines.push("");
+    lines.push(`**Warning:** ${migrationGroups} group(s) had all topics fail. The group may have been migrated or deleted.`);
+  }
+  if (errors.length > 0) {
+    lines.push("");
+    lines.push(`**Errors (${errors.length}):**`);
+    for (const e of errors.slice(0, 10)) {
+      lines.push(`- ${e}`);
+    }
+    if (errors.length > 10) {
+      lines.push(`... and ${errors.length - 10} more`);
+    }
+  }
+  return truncateMessage(lines.join("\n"));
+}
+async function handleDailyReportAll(ctx) {
+  const { workspaceDir, logger } = ctx;
+  const registry = readRegistry(workspaceDir);
+  const userId = ctx.userId ?? registry.topicManagerAdmins[0];
+  if (!userId) {
+    return { text: "Something went wrong \u2014 could not identify your user account." };
+  }
+  const auth = checkAuthorization(userId, "daily-report-all", registry);
+  if (!auth.authorized) {
+    return { text: auth.message ?? "Not authorized." };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const projectsBase = path14.join(workspaceDir, "projects");
+  const allEntries = Object.entries(registry.topics);
+  const reportedTopics = [];
+  const skippedTopics = [];
+  const errors = [];
+  const groupPostResults = /* @__PURE__ */ new Map();
+  const reports = [];
+  for (const [_key, entry] of allEntries) {
+    const capsuleDir = path14.join(projectsBase, entry.slug);
+    const statusContent = readFileOrNull(path14.join(capsuleDir, "STATUS.md"));
+    const statusTs = statusContent ? extractStatusTimestamp(statusContent) : null;
+    const eligibility = getDailyReportEligibility(entry, now, statusTs);
+    if (!eligibility.eligible) {
+      skippedTopics.push({ name: entry.name, reason: eligibility.skipReason });
+      continue;
+    }
+    try {
+      const doneContent = extractDoneSection(statusContent);
+      const blockers = extractBlockers(statusContent);
+      const nextContent = extractNextActions(statusContent);
+      const reportData = {
+        name: entry.name,
+        doneContent,
+        blockersContent: blockers,
+        nextContent
+      };
+      const reportText = buildDailyReport(reportData, "html");
+      reports.push({
+        slug: entry.slug,
+        groupId: entry.groupId,
+        threadId: entry.threadId,
+        text: reportText
+      });
+      const gk = entry.groupId;
+      if (!groupPostResults.has(gk)) {
+        groupPostResults.set(gk, { total: 0, failed: 0 });
+      }
+      groupPostResults.get(gk).total++;
+      reportedTopics.push({ name: entry.name, slug: entry.slug, status: "reported" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`${entry.slug}: ${msg}`);
+      logger.error(`[daily-report-all] Error processing ${entry.slug}: ${msg}`);
+      const gk = entry.groupId;
+      if (!groupPostResults.has(gk)) {
+        groupPostResults.set(gk, { total: 0, failed: 0 });
+      }
+      groupPostResults.get(gk).total++;
+      groupPostResults.get(gk).failed++;
+    }
+  }
+  const migrationGroups = [];
+  for (const [gid, stats] of groupPostResults) {
+    if (stats.total > 0 && stats.failed === stats.total) {
+      migrationGroups.push(gid);
+    }
+  }
+  let postFailures = 0;
+  const postFailedSlugs = /* @__PURE__ */ new Set();
+  if (ctx.postFn && reports.length > 0) {
+    const rateLimitedPost = createRateLimitedPoster(ctx.postFn);
+    for (const report of reports) {
+      try {
+        await rateLimitedPost(report.groupId, report.threadId, report.text);
+        await withRegistry(workspaceDir, (data) => {
+          const key = `${report.groupId}:${report.threadId}`;
+          const entry = data.topics[key];
+          if (entry) {
+            entry.lastDailyReportAt = now.toISOString();
+            entry.lastPostError = null;
+          }
+        });
+      } catch (err) {
+        postFailures++;
+        postFailedSlugs.add(report.slug);
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`[daily-report-all] Post failed for ${report.slug}: ${msg}`);
+        await withRegistry(workspaceDir, (data) => {
+          const key = `${report.groupId}:${report.threadId}`;
+          const entry = data.topics[key];
+          if (entry) {
+            entry.lastPostError = msg.slice(0, MAX_POST_ERROR_LENGTH);
+          }
+        });
+      }
+    }
+    for (const outcome of reportedTopics) {
+      if (postFailedSlugs.has(outcome.slug) && outcome.status === "reported") {
+        outcome.status = "post-failed";
+      }
+    }
+  } else if (reports.length > 0) {
+    await withRegistry(workspaceDir, (data) => {
+      for (const report of reports) {
+        const key = `${report.groupId}:${report.threadId}`;
+        const entry = data.topics[key];
+        if (entry) {
+          entry.lastDailyReportAt = now.toISOString();
+        }
+      }
+    });
+  }
+  return {
+    text: buildDailyReportAllSummary({
+      reportedTopics,
+      skippedTopics,
+      postFailures,
+      migrationGroups: migrationGroups.length,
+      errors
+    })
+  };
+}
+
 // src/commands/help.ts
 function handleHelp(_ctx) {
   return {
@@ -11569,6 +11808,16 @@ function createTopicManagerTool(deps) {
           logger.error(`[activity-tracking] Failed: ${msg}`);
         });
       }
+      try {
+        const migrationReg = readRegistry(workspaceDir);
+        if (migrationReg.autopilotEnabled && !migrationReg.dailyReportCronJobId) {
+          void ensureCombinedCron(workspaceDir, rpc, logger).then(() => cleanupPerTopicCrons(workspaceDir, rpc, logger)).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`[cron-migration] Failed: ${msg}`);
+          });
+        }
+      } catch {
+      }
       try {
         switch (subCommand) {
           case "init":
@@ -11599,7 +11848,12 @@ function createTopicManagerTool(deps) {
           case "autopilot":
             return await handleAutopilot(ctx, args);
           case "daily-report":
+            if (flags.has("--all") || flags.has("all")) {
+              return await handleDailyReportAll(ctx);
+            }
             return await handleDailyReport(ctx);
+          case "daily-report-all":
+            return await handleDailyReportAll(ctx);
           case "help":
             return await handleHelp(ctx);
           default:
@@ -11721,25 +11975,25 @@ async function handleCallback(data, ctx) {
 // src/index.ts
 function resolveConfigDir() {
   const thisFile = new URL(import.meta.url).pathname;
-  const parts = thisFile.split(path14.sep);
+  const parts = thisFile.split(path15.sep);
   const extIndex = parts.lastIndexOf("extensions");
   if (extIndex > 0) {
-    const candidate = parts.slice(0, extIndex).join(path14.sep);
-    if (fs13.existsSync(path14.join(candidate, "openclaw.json")) || fs13.existsSync(path14.join(candidate, "extensions"))) {
+    const candidate = parts.slice(0, extIndex).join(path15.sep);
+    if (fs13.existsSync(path15.join(candidate, "openclaw.json")) || fs13.existsSync(path15.join(candidate, "extensions"))) {
       return candidate;
     }
   }
   const envDir = process.env["OPENCLAW_CONFIG_DIR"];
-  if (envDir && fs13.existsSync(envDir)) return path14.resolve(envDir);
+  if (envDir && fs13.existsSync(envDir)) return path15.resolve(envDir);
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const defaultDir = path14.join(homeDir, ".openclaw");
+  const defaultDir = path15.join(homeDir, ".openclaw");
   if (fs13.existsSync(defaultDir)) return defaultDir;
   return void 0;
 }
 function register(api) {
   const resolvedConfigDir = resolveConfigDir();
   const configDir = api.configDir ?? api.pluginConfig?.configDir ?? resolvedConfigDir;
-  const workspaceDir = api.workspaceDir ?? api.pluginConfig?.workspaceDir ?? (resolvedConfigDir ? path14.join(resolvedConfigDir, "workspace") : void 0);
+  const workspaceDir = api.workspaceDir ?? api.pluginConfig?.workspaceDir ?? (resolvedConfigDir ? path15.join(resolvedConfigDir, "workspace") : void 0);
   if (!configDir || !workspaceDir) {
     api.logger.error(
       "telegram-manager: configDir or workspaceDir not available. Plugin cannot initialize."