openclaw-telegram-manager 1.3.10 → 2.0.0

package/dist/plugin.js

@@ -60,54 +60,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs13) {
+    function patch(fs12) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs13);
-      }
-      if (!fs13.lutimes) {
-        patchLutimes(fs13);
-      }
-      fs13.chown = chownFix(fs13.chown);
-      fs13.fchown = chownFix(fs13.fchown);
-      fs13.lchown = chownFix(fs13.lchown);
-      fs13.chmod = chmodFix(fs13.chmod);
-      fs13.fchmod = chmodFix(fs13.fchmod);
-      fs13.lchmod = chmodFix(fs13.lchmod);
-      fs13.chownSync = chownFixSync(fs13.chownSync);
-      fs13.fchownSync = chownFixSync(fs13.fchownSync);
-      fs13.lchownSync = chownFixSync(fs13.lchownSync);
-      fs13.chmodSync = chmodFixSync(fs13.chmodSync);
-      fs13.fchmodSync = chmodFixSync(fs13.fchmodSync);
-      fs13.lchmodSync = chmodFixSync(fs13.lchmodSync);
-      fs13.stat = statFix(fs13.stat);
-      fs13.fstat = statFix(fs13.fstat);
-      fs13.lstat = statFix(fs13.lstat);
-      fs13.statSync = statFixSync(fs13.statSync);
-      fs13.fstatSync = statFixSync(fs13.fstatSync);
-      fs13.lstatSync = statFixSync(fs13.lstatSync);
-      if (fs13.chmod && !fs13.lchmod) {
-        fs13.lchmod = function(path14, mode, cb) {
+        patchLchmod(fs12);
+      }
+      if (!fs12.lutimes) {
+        patchLutimes(fs12);
+      }
+      fs12.chown = chownFix(fs12.chown);
+      fs12.fchown = chownFix(fs12.fchown);
+      fs12.lchown = chownFix(fs12.lchown);
+      fs12.chmod = chmodFix(fs12.chmod);
+      fs12.fchmod = chmodFix(fs12.fchmod);
+      fs12.lchmod = chmodFix(fs12.lchmod);
+      fs12.chownSync = chownFixSync(fs12.chownSync);
+      fs12.fchownSync = chownFixSync(fs12.fchownSync);
+      fs12.lchownSync = chownFixSync(fs12.lchownSync);
+      fs12.chmodSync = chmodFixSync(fs12.chmodSync);
+      fs12.fchmodSync = chmodFixSync(fs12.fchmodSync);
+      fs12.lchmodSync = chmodFixSync(fs12.lchmodSync);
+      fs12.stat = statFix(fs12.stat);
+      fs12.fstat = statFix(fs12.fstat);
+      fs12.lstat = statFix(fs12.lstat);
+      fs12.statSync = statFixSync(fs12.statSync);
+      fs12.fstatSync = statFixSync(fs12.fstatSync);
+      fs12.lstatSync = statFixSync(fs12.lstatSync);
+      if (fs12.chmod && !fs12.lchmod) {
+        fs12.lchmod = function(path13, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs13.lchmodSync = function() {
+        fs12.lchmodSync = function() {
         };
       }
-      if (fs13.chown && !fs13.lchown) {
-        fs13.lchown = function(path14, uid, gid, cb) {
+      if (fs12.chown && !fs12.lchown) {
+        fs12.lchown = function(path13, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs13.lchownSync = function() {
+        fs12.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs13.rename = typeof fs13.rename !== "function" ? fs13.rename : (function(fs$rename) {
+        fs12.rename = typeof fs12.rename !== "function" ? fs12.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs13.stat(to, function(stater, st) {
+                  fs12.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -123,9 +123,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs13.rename);
+        })(fs12.rename);
       }
-      fs13.read = typeof fs13.read !== "function" ? fs13.read : (function(fs$read) {
+      fs12.read = typeof fs12.read !== "function" ? fs12.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -133,22 +133,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs13.read);
-      fs13.readSync = typeof fs13.readSync !== "function" ? fs13.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs12.read);
+      fs12.readSync = typeof fs12.readSync !== "function" ? fs12.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs13, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs12, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -158,11 +158,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs13.readSync);
-      function patchLchmod(fs14) {
-        fs14.lchmod = function(path14, mode, callback) {
-          fs14.open(
-            path14,
+      })(fs12.readSync);
+      function patchLchmod(fs13) {
+        fs13.lchmod = function(path13, mode, callback) {
+          fs13.open(
+            path13,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -170,80 +170,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs14.fchmod(fd, mode, function(err2) {
-                fs14.close(fd, function(err22) {
+              fs13.fchmod(fd, mode, function(err2) {
+                fs13.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs14.lchmodSync = function(path14, mode) {
-          var fd = fs14.openSync(path14, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs13.lchmodSync = function(path13, mode) {
+          var fd = fs13.openSync(path13, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs14.fchmodSync(fd, mode);
+            ret = fs13.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs14.closeSync(fd);
+                fs13.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs14.closeSync(fd);
+              fs13.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs14) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs14.futimes) {
-          fs14.lutimes = function(path14, at, mt, cb) {
-            fs14.open(path14, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs13) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs13.futimes) {
+          fs13.lutimes = function(path13, at, mt, cb) {
+            fs13.open(path13, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs14.futimes(fd, at, mt, function(er2) {
-                fs14.close(fd, function(er22) {
+              fs13.futimes(fd, at, mt, function(er2) {
+                fs13.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs14.lutimesSync = function(path14, at, mt) {
-            var fd = fs14.openSync(path14, constants.O_SYMLINK);
+          fs13.lutimesSync = function(path13, at, mt) {
+            var fd = fs13.openSync(path13, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs14.futimesSync(fd, at, mt);
+              ret = fs13.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs14.closeSync(fd);
+                  fs13.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs14.closeSync(fd);
+                fs13.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs14.futimes) {
-          fs14.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs13.futimes) {
+          fs13.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs14.lutimesSync = function() {
+          fs13.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs13, target, mode, function(er) {
+          return orig.call(fs12, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -253,7 +253,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs13, target, mode);
+            return orig.call(fs12, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -262,7 +262,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs13, target, uid, gid, function(er) {
+          return orig.call(fs12, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -272,7 +272,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs13, target, uid, gid);
+            return orig.call(fs12, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -292,13 +292,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs13, target, options, callback) : orig.call(fs13, target, callback);
+          return options ? orig.call(fs12, target, options, callback) : orig.call(fs12, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs13, target, options) : orig.call(fs13, target);
+          var stats = options ? orig.call(fs12, target, options) : orig.call(fs12, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -327,16 +327,16 @@ var require_legacy_streams = __commonJS({
   "node_modules/graceful-fs/legacy-streams.js"(exports, module) {
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs13) {
+    function legacy(fs12) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path14, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
+      function ReadStream(path13, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
         Stream.call(this);
         var self = this;
-        this.path = path14;
+        this.path = path13;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -370,7 +370,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs13.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs12.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -381,10 +381,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path14, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
+      function WriteStream(path13, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path13, options);
         Stream.call(this);
-        this.path = path14;
+        this.path = path13;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -409,7 +409,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs13.open;
+          this._open = fs12.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -444,7 +444,7 @@ var require_clone = __commonJS({
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports, module) {
-    var fs13 = __require("fs");
+    var fs12 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -476,12 +476,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs13[gracefulQueue]) {
+    if (!fs12[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs13, queue);
-      fs13.close = (function(fs$close) {
+      publishQueue(fs12, queue);
+      fs12.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs13, fd, function(err) {
+          return fs$close.call(fs12, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -493,48 +493,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs13.close);
-      fs13.closeSync = (function(fs$closeSync) {
+      })(fs12.close);
+      fs12.closeSync = (function(fs$closeSync) {
         function closeSync2(fd) {
-          fs$closeSync.apply(fs13, arguments);
+          fs$closeSync.apply(fs12, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync2, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync2;
-      })(fs13.closeSync);
+      })(fs12.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs13[gracefulQueue]);
-          __require("assert").equal(fs13[gracefulQueue].length, 0);
+          debug(fs12[gracefulQueue]);
+          __require("assert").equal(fs12[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs13[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs13));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs13.__patched) {
-      module.exports = patch(fs13);
-      fs13.__patched = true;
-    }
-    function patch(fs14) {
-      polyfills(fs14);
-      fs14.gracefulify = patch;
-      fs14.createReadStream = createReadStream;
-      fs14.createWriteStream = createWriteStream;
-      var fs$readFile = fs14.readFile;
-      fs14.readFile = readFile;
-      function readFile(path14, options, cb) {
+      publishQueue(global, fs12[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs12));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs12.__patched) {
+      module.exports = patch(fs12);
+      fs12.__patched = true;
+    }
+    function patch(fs13) {
+      polyfills(fs13);
+      fs13.gracefulify = patch;
+      fs13.createReadStream = createReadStream;
+      fs13.createWriteStream = createWriteStream;
+      var fs$readFile = fs13.readFile;
+      fs13.readFile = readFile;
+      function readFile(path13, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path14, options, cb);
-        function go$readFile(path15, options2, cb2, startTime) {
-          return fs$readFile(path15, options2, function(err) {
+        return go$readFile(path13, options, cb);
+        function go$readFile(path14, options2, cb2, startTime) {
+          return fs$readFile(path14, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path15, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path14, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -542,16 +542,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs14.writeFile;
-      fs14.writeFile = writeFile;
-      function writeFile(path14, data, options, cb) {
+      var fs$writeFile = fs13.writeFile;
+      fs13.writeFile = writeFile;
+      function writeFile(path13, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path14, data, options, cb);
-        function go$writeFile(path15, data2, options2, cb2, startTime) {
-          return fs$writeFile(path15, data2, options2, function(err) {
+        return go$writeFile(path13, data, options, cb);
+        function go$writeFile(path14, data2, options2, cb2, startTime) {
+          return fs$writeFile(path14, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -559,17 +559,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs14.appendFile;
+      var fs$appendFile = fs13.appendFile;
       if (fs$appendFile)
-        fs14.appendFile = appendFile;
-      function appendFile(path14, data, options, cb) {
+        fs13.appendFile = appendFile;
+      function appendFile(path13, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path14, data, options, cb);
-        function go$appendFile(path15, data2, options2, cb2, startTime) {
-          return fs$appendFile(path15, data2, options2, function(err) {
+        return go$appendFile(path13, data, options, cb);
+        function go$appendFile(path14, data2, options2, cb2, startTime) {
+          return fs$appendFile(path14, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -577,9 +577,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs14.copyFile;
+      var fs$copyFile = fs13.copyFile;
       if (fs$copyFile)
-        fs14.copyFile = copyFile;
+        fs13.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -597,34 +597,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs14.readdir;
-      fs14.readdir = readdir;
+      var fs$readdir = fs13.readdir;
+      fs13.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path14, options, cb) {
+      function readdir(path13, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, fs$readdirCallback(
-            path15,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path14, options2, cb2, startTime) {
+          return fs$readdir(path14, fs$readdirCallback(
+            path14,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, options2, fs$readdirCallback(
-            path15,
+        } : function go$readdir2(path14, options2, cb2, startTime) {
+          return fs$readdir(path14, options2, fs$readdirCallback(
+            path14,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path14, options, cb);
-        function fs$readdirCallback(path15, options2, cb2, startTime) {
+        return go$readdir(path13, options, cb);
+        function fs$readdirCallback(path14, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path15, options2, cb2],
+                [path14, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -639,21 +639,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs14);
+        var legStreams = legacy(fs13);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs14.ReadStream;
+      var fs$ReadStream = fs13.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs14.WriteStream;
+      var fs$WriteStream = fs13.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs14, "ReadStream", {
+      Object.defineProperty(fs13, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -663,7 +663,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs14, "WriteStream", {
+      Object.defineProperty(fs13, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -674,7 +674,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs14, "FileReadStream", {
+      Object.defineProperty(fs13, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -685,7 +685,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs14, "FileWriteStream", {
+      Object.defineProperty(fs13, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -695,7 +695,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path14, options) {
+      function ReadStream(path13, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -715,7 +715,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path14, options) {
+      function WriteStream(path13, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -733,22 +733,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path14, options) {
-        return new fs14.ReadStream(path14, options);
+      function createReadStream(path13, options) {
+        return new fs13.ReadStream(path13, options);
       }
-      function createWriteStream(path14, options) {
-        return new fs14.WriteStream(path14, options);
+      function createWriteStream(path13, options) {
+        return new fs13.WriteStream(path13, options);
       }
-      var fs$open = fs14.open;
-      fs14.open = open;
-      function open(path14, flags, mode, cb) {
+      var fs$open = fs13.open;
+      fs13.open = open;
+      function open(path13, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path14, flags, mode, cb);
-        function go$open(path15, flags2, mode2, cb2, startTime) {
-          return fs$open(path15, flags2, mode2, function(err, fd) {
+        return go$open(path13, flags, mode, cb);
+        function go$open(path14, flags2, mode2, cb2, startTime) {
+          return fs$open(path14, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path15, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path14, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -756,20 +756,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs14;
+      return fs13;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs13[gracefulQueue].push(elem);
+      fs12[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs13[gracefulQueue].length; ++i) {
-        if (fs13[gracefulQueue][i].length > 2) {
-          fs13[gracefulQueue][i][3] = now;
-          fs13[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs12[gracefulQueue].length; ++i) {
+        if (fs12[gracefulQueue][i].length > 2) {
+          fs12[gracefulQueue][i][3] = now;
+          fs12[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -777,9 +777,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs13[gracefulQueue].length === 0)
+      if (fs12[gracefulQueue].length === 0)
         return;
-      var elem = fs13[gracefulQueue].shift();
+      var elem = fs12[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -801,7 +801,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs13[gracefulQueue].push(elem);
+          fs12[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -1236,10 +1236,10 @@ var require_mtime_precision = __commonJS({
   "node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
     "use strict";
     var cacheSymbol = Symbol();
-    function probe(file, fs13, callback) {
-      const cachedPrecision = fs13[cacheSymbol];
+    function probe(file, fs12, callback) {
+      const cachedPrecision = fs12[cacheSymbol];
       if (cachedPrecision) {
-        return fs13.stat(file, (err, stat) => {
+        return fs12.stat(file, (err, stat) => {
           if (err) {
             return callback(err);
           }
@@ -1247,16 +1247,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs13.utimes(file, mtime, mtime, (err) => {
+      fs12.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs13.stat(file, (err2, stat) => {
+        fs12.stat(file, (err2, stat) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs13, cacheSymbol, { value: precision });
+          Object.defineProperty(fs12, cacheSymbol, { value: precision });
           callback(null, stat.mtime, precision);
         });
       });
@@ -1277,8 +1277,8 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path14 = __require("path");
-    var fs13 = require_graceful_fs();
+    var path13 = __require("path");
+    var fs12 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -1288,7 +1288,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path14.resolve(file));
+        return callback(null, path13.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -1409,7 +1409,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs13,
+        fs: fs12,
         onCompromised: (err) => {
           throw err;
         },
@@ -1453,7 +1453,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs13,
+        fs: fs12,
         realpath: true,
         ...options
       };
@@ -1475,7 +1475,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs13,
+        fs: fs12,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -1514,16 +1514,16 @@ var require_lockfile = __commonJS({
 var require_adapter = __commonJS({
   "node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
-    function createSyncFs(fs14) {
+    var fs12 = require_graceful_fs();
+    function createSyncFs(fs13) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs14 };
+      const newFs = { ...fs13 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs14[`${method}Sync`](...args);
+            ret = fs13[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1561,7 +1561,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs13);
+      options.fs = createSyncFs(options.fs || fs12);
       if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
         throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
       }
@@ -2724,8 +2724,8 @@ var require_lib = __commonJS({
 });
 
 // src/index.ts
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 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, path14, value, errors = []) {
+function Create(errorType, schema, path13, value, errors = []) {
   return {
     type: errorType,
     schema,
-    path: path14,
+    path: path13,
     value,
-    message: GetErrorFunction()({ errorType, path: path14, schema, value, errors }),
+    message: GetErrorFunction()({ errorType, path: path13, schema, value, errors }),
     errors
   };
 }
-function* FromAny3(schema, references, path14, value) {
+function* FromAny3(schema, references, path13, value) {
 }
-function* FromArgument3(schema, references, path14, value) {
+function* FromArgument3(schema, references, path13, value) {
 }
-function* FromArray8(schema, references, path14, value) {
+function* FromArray8(schema, references, path13, value) {
   if (!IsArray2(value)) {
-    return yield Create(ValueErrorType.Array, schema, path14, value);
+    return yield Create(ValueErrorType.Array, schema, path13, value);
   }
   if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield Create(ValueErrorType.ArrayMinItems, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMinItems, schema, path13, value);
   }
   if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield Create(ValueErrorType.ArrayMaxItems, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path13, value);
   }
   for (let i = 0; i < value.length; i++) {
-    yield* Visit6(schema.items, references, `${path14}/${i}`, value[i]);
+    yield* Visit6(schema.items, references, `${path13}/${i}`, value[i]);
   }
   if (schema.uniqueItems === true && !(function() {
     const set = /* @__PURE__ */ new Set();
@@ -6337,116 +6337,116 @@ function* FromArray8(schema, references, path14, value) {
     }
     return true;
   })()) {
-    yield Create(ValueErrorType.ArrayUniqueItems, schema, path14, value);
+    yield Create(ValueErrorType.ArrayUniqueItems, schema, path13, 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, `${path14}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+  const containsCount = value.reduce((acc, value2, index) => Visit6(containsSchema, references, `${path13}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
   if (containsCount === 0) {
-    yield Create(ValueErrorType.ArrayContains, schema, path14, value);
+    yield Create(ValueErrorType.ArrayContains, schema, path13, value);
   }
   if (IsNumber2(schema.minContains) && containsCount < schema.minContains) {
-    yield Create(ValueErrorType.ArrayMinContains, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMinContains, schema, path13, value);
   }
   if (IsNumber2(schema.maxContains) && containsCount > schema.maxContains) {
-    yield Create(ValueErrorType.ArrayMaxContains, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path13, value);
   }
 }
-function* FromAsyncIterator5(schema, references, path14, value) {
+function* FromAsyncIterator5(schema, references, path13, value) {
   if (!IsAsyncIterator2(value))
-    yield Create(ValueErrorType.AsyncIterator, schema, path14, value);
+    yield Create(ValueErrorType.AsyncIterator, schema, path13, value);
 }
-function* FromBigInt3(schema, references, path14, value) {
+function* FromBigInt3(schema, references, path13, value) {
   if (!IsBigInt2(value))
-    return yield Create(ValueErrorType.BigInt, schema, path14, value);
+    return yield Create(ValueErrorType.BigInt, schema, path13, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.BigIntMaximum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.BigIntMinimum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield Create(ValueErrorType.BigIntMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path13, value);
   }
 }
-function* FromBoolean3(schema, references, path14, value) {
+function* FromBoolean3(schema, references, path13, value) {
   if (!IsBoolean2(value))
-    yield Create(ValueErrorType.Boolean, schema, path14, value);
+    yield Create(ValueErrorType.Boolean, schema, path13, value);
 }
-function* FromConstructor5(schema, references, path14, value) {
-  yield* Visit6(schema.returns, references, path14, value.prototype);
+function* FromConstructor5(schema, references, path13, value) {
+  yield* Visit6(schema.returns, references, path13, value.prototype);
 }
-function* FromDate3(schema, references, path14, value) {
+function* FromDate3(schema, references, path13, value) {
   if (!IsDate2(value))
-    return yield Create(ValueErrorType.Date, schema, path14, value);
+    return yield Create(ValueErrorType.Date, schema, path13, value);
   if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path13, value);
   }
   if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path13, value);
   }
   if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path13, value);
   }
   if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path13, value);
   }
   if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path13, value);
   }
 }
-function* FromFunction5(schema, references, path14, value) {
+function* FromFunction5(schema, references, path13, value) {
   if (!IsFunction2(value))
-    yield Create(ValueErrorType.Function, schema, path14, value);
+    yield Create(ValueErrorType.Function, schema, path13, value);
 }
-function* FromImport2(schema, references, path14, value) {
+function* FromImport2(schema, references, path13, value) {
   const definitions = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  yield* Visit6(target, [...references, ...definitions], path14, value);
+  yield* Visit6(target, [...references, ...definitions], path13, value);
 }
-function* FromInteger3(schema, references, path14, value) {
+function* FromInteger3(schema, references, path13, value) {
   if (!IsInteger(value))
-    return yield Create(ValueErrorType.Integer, schema, path14, value);
+    return yield Create(ValueErrorType.Integer, schema, path13, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.IntegerMaximum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.IntegerMinimum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.IntegerMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path13, value);
   }
 }
-function* FromIntersect10(schema, references, path14, value) {
+function* FromIntersect10(schema, references, path13, value) {
   let hasError = false;
   for (const inner of schema.allOf) {
-    for (const error of Visit6(inner, references, path14, value)) {
+    for (const error of Visit6(inner, references, path13, value)) {
       hasError = true;
       yield error;
     }
   }
   if (hasError) {
-    return yield Create(ValueErrorType.Intersect, schema, path14, value);
+    return yield Create(ValueErrorType.Intersect, schema, path13, 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, `${path14}/${valueKey}`, value);
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path13}/${valueKey}`, value);
       }
     }
   }
@@ -6454,59 +6454,59 @@ function* FromIntersect10(schema, references, path14, value) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        const next = Visit6(schema.unevaluatedProperties, references, `${path14}/${valueKey}`, value[valueKey]).next();
+        const next = Visit6(schema.unevaluatedProperties, references, `${path13}/${valueKey}`, value[valueKey]).next();
         if (!next.done)
           yield next.value;
       }
     }
   }
 }
-function* FromIterator5(schema, references, path14, value) {
+function* FromIterator5(schema, references, path13, value) {
   if (!IsIterator2(value))
-    yield Create(ValueErrorType.Iterator, schema, path14, value);
+    yield Create(ValueErrorType.Iterator, schema, path13, value);
 }
-function* FromLiteral4(schema, references, path14, value) {
+function* FromLiteral4(schema, references, path13, value) {
   if (!(value === schema.const))
-    yield Create(ValueErrorType.Literal, schema, path14, value);
+    yield Create(ValueErrorType.Literal, schema, path13, value);
 }
-function* FromNever3(schema, references, path14, value) {
-  yield Create(ValueErrorType.Never, schema, path14, value);
+function* FromNever3(schema, references, path13, value) {
+  yield Create(ValueErrorType.Never, schema, path13, value);
 }
-function* FromNot3(schema, references, path14, value) {
-  if (Visit6(schema.not, references, path14, value).next().done === true)
-    yield Create(ValueErrorType.Not, schema, path14, value);
+function* FromNot3(schema, references, path13, value) {
+  if (Visit6(schema.not, references, path13, value).next().done === true)
+    yield Create(ValueErrorType.Not, schema, path13, value);
 }
-function* FromNull3(schema, references, path14, value) {
+function* FromNull3(schema, references, path13, value) {
   if (!IsNull2(value))
-    yield Create(ValueErrorType.Null, schema, path14, value);
+    yield Create(ValueErrorType.Null, schema, path13, value);
 }
-function* FromNumber3(schema, references, path14, value) {
+function* FromNumber3(schema, references, path13, value) {
   if (!TypeSystemPolicy.IsNumberLike(value))
-    return yield Create(ValueErrorType.Number, schema, path14, value);
+    return yield Create(ValueErrorType.Number, schema, path13, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.NumberMaximum, schema, path14, value);
+    yield Create(ValueErrorType.NumberMaximum, schema, path13, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.NumberMinimum, schema, path14, value);
+    yield Create(ValueErrorType.NumberMinimum, schema, path13, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.NumberMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path13, value);
   }
 }
-function* FromObject9(schema, references, path14, value) {
+function* FromObject9(schema, references, path13, value) {
   if (!TypeSystemPolicy.IsObjectLike(value))
-    return yield Create(ValueErrorType.Object, schema, path14, value);
+    return yield Create(ValueErrorType.Object, schema, path13, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, value);
   }
   const requiredKeys = Array.isArray(schema.required) ? schema.required : [];
   const knownKeys = Object.getOwnPropertyNames(schema.properties);
@@ -6514,12 +6514,12 @@ function* FromObject9(schema, references, path14, value) {
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey))
       continue;
-    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path14}/${EscapeKey(requiredKey)}`, void 0);
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path13}/${EscapeKey(requiredKey)}`, void 0);
   }
   if (schema.additionalProperties === false) {
     for (const valueKey of unknownKeys) {
       if (!knownKeys.includes(valueKey)) {
-        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path14}/${EscapeKey(valueKey)}`, value[valueKey]);
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path13}/${EscapeKey(valueKey)}`, value[valueKey]);
       }
     }
   }
@@ -6527,235 +6527,235 @@ function* FromObject9(schema, references, path14, value) {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey))
         continue;
-      yield* Visit6(schema.additionalProperties, references, `${path14}/${EscapeKey(valueKey)}`, value[valueKey]);
+      yield* Visit6(schema.additionalProperties, references, `${path13}/${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, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
+      yield* Visit6(property, references, `${path13}/${EscapeKey(knownKey)}`, value[knownKey]);
       if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
-        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path14}/${EscapeKey(knownKey)}`, void 0);
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path13}/${EscapeKey(knownKey)}`, void 0);
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit6(property, references, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
+        yield* Visit6(property, references, `${path13}/${EscapeKey(knownKey)}`, value[knownKey]);
       }
     }
   }
 }
-function* FromPromise5(schema, references, path14, value) {
+function* FromPromise5(schema, references, path13, value) {
   if (!IsPromise(value))
-    yield Create(ValueErrorType.Promise, schema, path14, value);
+    yield Create(ValueErrorType.Promise, schema, path13, value);
 }
-function* FromRecord5(schema, references, path14, value) {
+function* FromRecord5(schema, references, path13, value) {
   if (!TypeSystemPolicy.IsRecordLike(value))
-    return yield Create(ValueErrorType.Object, schema, path14, value);
+    return yield Create(ValueErrorType.Object, schema, path13, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, 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, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
+      yield* Visit6(patternSchema, references, `${path13}/${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, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
+        yield* Visit6(schema.additionalProperties, references, `${path13}/${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, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path13}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
 }
-function* FromRef6(schema, references, path14, value) {
-  yield* Visit6(Deref(schema, references), references, path14, value);
+function* FromRef6(schema, references, path13, value) {
+  yield* Visit6(Deref(schema, references), references, path13, value);
 }
-function* FromRegExp3(schema, references, path14, value) {
+function* FromRegExp3(schema, references, path13, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path13, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
   }
   const regex = new RegExp(schema.source, schema.flags);
   if (!regex.test(value)) {
-    return yield Create(ValueErrorType.RegExp, schema, path14, value);
+    return yield Create(ValueErrorType.RegExp, schema, path13, value);
   }
 }
-function* FromString3(schema, references, path14, value) {
+function* FromString3(schema, references, path13, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path13, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
   }
   if (IsString2(schema.pattern)) {
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
-      yield Create(ValueErrorType.StringPattern, schema, path14, value);
+      yield Create(ValueErrorType.StringPattern, schema, path13, value);
     }
   }
   if (IsString2(schema.format)) {
     if (!format_exports.Has(schema.format)) {
-      yield Create(ValueErrorType.StringFormatUnknown, schema, path14, value);
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path13, value);
     } else {
       const format = format_exports.Get(schema.format);
       if (!format(value)) {
-        yield Create(ValueErrorType.StringFormat, schema, path14, value);
+        yield Create(ValueErrorType.StringFormat, schema, path13, value);
       }
     }
   }
 }
-function* FromSymbol3(schema, references, path14, value) {
+function* FromSymbol3(schema, references, path13, value) {
   if (!IsSymbol2(value))
-    yield Create(ValueErrorType.Symbol, schema, path14, value);
+    yield Create(ValueErrorType.Symbol, schema, path13, value);
 }
-function* FromTemplateLiteral5(schema, references, path14, value) {
+function* FromTemplateLiteral5(schema, references, path13, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path13, value);
   const regex = new RegExp(schema.pattern);
   if (!regex.test(value)) {
-    yield Create(ValueErrorType.StringPattern, schema, path14, value);
+    yield Create(ValueErrorType.StringPattern, schema, path13, value);
   }
 }
-function* FromThis2(schema, references, path14, value) {
-  yield* Visit6(Deref(schema, references), references, path14, value);
+function* FromThis2(schema, references, path13, value) {
+  yield* Visit6(Deref(schema, references), references, path13, value);
 }
-function* FromTuple7(schema, references, path14, value) {
+function* FromTuple7(schema, references, path13, value) {
   if (!IsArray2(value))
-    return yield Create(ValueErrorType.Tuple, schema, path14, value);
+    return yield Create(ValueErrorType.Tuple, schema, path13, value);
   if (schema.items === void 0 && !(value.length === 0)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path14, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
   }
   if (!(value.length === schema.maxItems)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path14, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
   }
   if (!schema.items) {
     return;
   }
   for (let i = 0; i < schema.items.length; i++) {
-    yield* Visit6(schema.items[i], references, `${path14}/${i}`, value[i]);
+    yield* Visit6(schema.items[i], references, `${path13}/${i}`, value[i]);
   }
 }
-function* FromUndefined3(schema, references, path14, value) {
+function* FromUndefined3(schema, references, path13, value) {
   if (!IsUndefined2(value))
-    yield Create(ValueErrorType.Undefined, schema, path14, value);
+    yield Create(ValueErrorType.Undefined, schema, path13, value);
 }
-function* FromUnion12(schema, references, path14, value) {
+function* FromUnion12(schema, references, path13, value) {
   if (Check(schema, references, value))
     return;
-  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path14, value)));
-  yield Create(ValueErrorType.Union, schema, path14, value, errors);
+  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path13, value)));
+  yield Create(ValueErrorType.Union, schema, path13, value, errors);
 }
-function* FromUint8Array3(schema, references, path14, value) {
+function* FromUint8Array3(schema, references, path13, value) {
   if (!IsUint8Array2(value))
-    return yield Create(ValueErrorType.Uint8Array, schema, path14, value);
+    return yield Create(ValueErrorType.Uint8Array, schema, path13, value);
   if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path14, value);
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path13, value);
   }
   if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path14, value);
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path13, value);
   }
 }
-function* FromUnknown3(schema, references, path14, value) {
+function* FromUnknown3(schema, references, path13, value) {
 }
-function* FromVoid3(schema, references, path14, value) {
+function* FromVoid3(schema, references, path13, value) {
   if (!TypeSystemPolicy.IsVoidLike(value))
-    yield Create(ValueErrorType.Void, schema, path14, value);
+    yield Create(ValueErrorType.Void, schema, path13, value);
 }
-function* FromKind2(schema, references, path14, value) {
+function* FromKind2(schema, references, path13, value) {
   const check2 = type_exports2.Get(schema[Kind]);
   if (!check2(schema, value))
-    yield Create(ValueErrorType.Kind, schema, path14, value);
+    yield Create(ValueErrorType.Kind, schema, path13, value);
 }
-function* Visit6(schema, references, path14, value) {
+function* Visit6(schema, references, path13, value) {
   const references_ = IsDefined2(schema.$id) ? [...references, schema] : references;
   const schema_ = schema;
   switch (schema_[Kind]) {
     case "Any":
-      return yield* FromAny3(schema_, references_, path14, value);
+      return yield* FromAny3(schema_, references_, path13, value);
     case "Argument":
-      return yield* FromArgument3(schema_, references_, path14, value);
+      return yield* FromArgument3(schema_, references_, path13, value);
     case "Array":
-      return yield* FromArray8(schema_, references_, path14, value);
+      return yield* FromArray8(schema_, references_, path13, value);
     case "AsyncIterator":
-      return yield* FromAsyncIterator5(schema_, references_, path14, value);
+      return yield* FromAsyncIterator5(schema_, references_, path13, value);
     case "BigInt":
-      return yield* FromBigInt3(schema_, references_, path14, value);
+      return yield* FromBigInt3(schema_, references_, path13, value);
     case "Boolean":
-      return yield* FromBoolean3(schema_, references_, path14, value);
+      return yield* FromBoolean3(schema_, references_, path13, value);
     case "Constructor":
-      return yield* FromConstructor5(schema_, references_, path14, value);
+      return yield* FromConstructor5(schema_, references_, path13, value);
     case "Date":
-      return yield* FromDate3(schema_, references_, path14, value);
+      return yield* FromDate3(schema_, references_, path13, value);
     case "Function":
-      return yield* FromFunction5(schema_, references_, path14, value);
+      return yield* FromFunction5(schema_, references_, path13, value);
     case "Import":
-      return yield* FromImport2(schema_, references_, path14, value);
+      return yield* FromImport2(schema_, references_, path13, value);
     case "Integer":
-      return yield* FromInteger3(schema_, references_, path14, value);
+      return yield* FromInteger3(schema_, references_, path13, value);
     case "Intersect":
-      return yield* FromIntersect10(schema_, references_, path14, value);
+      return yield* FromIntersect10(schema_, references_, path13, value);
     case "Iterator":
-      return yield* FromIterator5(schema_, references_, path14, value);
+      return yield* FromIterator5(schema_, references_, path13, value);
     case "Literal":
-      return yield* FromLiteral4(schema_, references_, path14, value);
+      return yield* FromLiteral4(schema_, references_, path13, value);
     case "Never":
-      return yield* FromNever3(schema_, references_, path14, value);
+      return yield* FromNever3(schema_, references_, path13, value);
     case "Not":
-      return yield* FromNot3(schema_, references_, path14, value);
+      return yield* FromNot3(schema_, references_, path13, value);
     case "Null":
-      return yield* FromNull3(schema_, references_, path14, value);
+      return yield* FromNull3(schema_, references_, path13, value);
     case "Number":
-      return yield* FromNumber3(schema_, references_, path14, value);
+      return yield* FromNumber3(schema_, references_, path13, value);
     case "Object":
-      return yield* FromObject9(schema_, references_, path14, value);
+      return yield* FromObject9(schema_, references_, path13, value);
     case "Promise":
-      return yield* FromPromise5(schema_, references_, path14, value);
+      return yield* FromPromise5(schema_, references_, path13, value);
     case "Record":
-      return yield* FromRecord5(schema_, references_, path14, value);
+      return yield* FromRecord5(schema_, references_, path13, value);
     case "Ref":
-      return yield* FromRef6(schema_, references_, path14, value);
+      return yield* FromRef6(schema_, references_, path13, value);
     case "RegExp":
-      return yield* FromRegExp3(schema_, references_, path14, value);
+      return yield* FromRegExp3(schema_, references_, path13, value);
     case "String":
-      return yield* FromString3(schema_, references_, path14, value);
+      return yield* FromString3(schema_, references_, path13, value);
     case "Symbol":
-      return yield* FromSymbol3(schema_, references_, path14, value);
+      return yield* FromSymbol3(schema_, references_, path13, value);
     case "TemplateLiteral":
-      return yield* FromTemplateLiteral5(schema_, references_, path14, value);
+      return yield* FromTemplateLiteral5(schema_, references_, path13, value);
     case "This":
-      return yield* FromThis2(schema_, references_, path14, value);
+      return yield* FromThis2(schema_, references_, path13, value);
     case "Tuple":
-      return yield* FromTuple7(schema_, references_, path14, value);
+      return yield* FromTuple7(schema_, references_, path13, value);
     case "Undefined":
-      return yield* FromUndefined3(schema_, references_, path14, value);
+      return yield* FromUndefined3(schema_, references_, path13, value);
     case "Union":
-      return yield* FromUnion12(schema_, references_, path14, value);
+      return yield* FromUnion12(schema_, references_, path13, value);
     case "Uint8Array":
-      return yield* FromUint8Array3(schema_, references_, path14, value);
+      return yield* FromUint8Array3(schema_, references_, path13, value);
     case "Unknown":
-      return yield* FromUnknown3(schema_, references_, path14, value);
+      return yield* FromUnknown3(schema_, references_, path13, value);
     case "Void":
-      return yield* FromVoid3(schema_, references_, path14, value);
+      return yield* FromVoid3(schema_, references_, path13, value);
     default:
       if (!type_exports2.Has(schema_[Kind]))
         throw new ValueErrorsUnknownTypeError(schema);
-      return yield* FromKind2(schema_, references_, path14, value);
+      return yield* FromKind2(schema_, references_, path13, value);
   }
 }
 function Errors(...args) {
@@ -7797,58 +7797,58 @@ var TransformDecodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformDecodeError = class extends TypeBoxError {
-  constructor(schema, path14, value, error) {
+  constructor(schema, path13, value, error) {
     super(error instanceof Error ? error.message : "Unknown error");
     this.schema = schema;
-    this.path = path14;
+    this.path = path13;
     this.value = value;
     this.error = error;
   }
 };
-function Default3(schema, path14, value) {
+function Default3(schema, path13, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
-    throw new TransformDecodeError(schema, path14, value, error);
+    throw new TransformDecodeError(schema, path13, value, error);
   }
 }
-function FromArray14(schema, references, path14, value) {
-  return IsArray2(value) ? Default3(schema, path14, value.map((value2, index) => Visit11(schema.items, references, `${path14}/${index}`, value2))) : Default3(schema, path14, value);
+function FromArray14(schema, references, path13, value) {
+  return IsArray2(value) ? Default3(schema, path13, value.map((value2, index) => Visit11(schema.items, references, `${path13}/${index}`, value2))) : Default3(schema, path13, value);
 }
-function FromIntersect15(schema, references, path14, value) {
+function FromIntersect15(schema, references, path13, value) {
   if (!IsObject2(value) || IsValueType(value))
-    return Default3(schema, path14, value);
+    return Default3(schema, path13, 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, `${path14}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit11(knownSchema, references, `${path13}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default3(schema, path14, knownProperties);
+    return Default3(schema, path13, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(unevaluatedProperties, `${path13}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path13, unknownProperties);
 }
-function FromImport7(schema, references, path14, value) {
+function FromImport7(schema, references, path13, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Visit11(target, [...references, ...additional], path14, value);
-  return Default3(schema, path14, result);
+  const result = Visit11(target, [...references, ...additional], path13, value);
+  return Default3(schema, path13, result);
 }
-function FromNot5(schema, references, path14, value) {
-  return Default3(schema, path14, Visit11(schema.not, references, path14, value));
+function FromNot5(schema, references, path13, value) {
+  return Default3(schema, path13, Visit11(schema.not, references, path13, value));
 }
-function FromObject15(schema, references, path14, value) {
+function FromObject15(schema, references, path13, value) {
   if (!IsObject2(value))
-    return Default3(schema, path14, value);
+    return Default3(schema, path13, value);
   const knownKeys = KeyOfPropertyKeys(schema);
   const knownProperties = { ...value };
   for (const key of knownKeys) {
@@ -7856,90 +7856,90 @@ function FromObject15(schema, references, path14, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit11(schema.properties[key], references, `${path14}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit11(schema.properties[key], references, `${path13}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path14, knownProperties);
+    return Default3(schema, path13, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path13}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path13, unknownProperties);
 }
-function FromRecord10(schema, references, path14, value) {
+function FromRecord10(schema, references, path13, value) {
   if (!IsObject2(value))
-    return Default3(schema, path14, value);
+    return Default3(schema, path13, 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, `${path14}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path13}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path14, knownProperties);
+    return Default3(schema, path13, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path13}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path13, unknownProperties);
 }
-function FromRef11(schema, references, path14, value) {
+function FromRef11(schema, references, path13, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path14, Visit11(target, references, path14, value));
+  return Default3(schema, path13, Visit11(target, references, path13, value));
 }
-function FromThis7(schema, references, path14, value) {
+function FromThis7(schema, references, path13, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path14, Visit11(target, references, path14, value));
+  return Default3(schema, path13, Visit11(target, references, path13, value));
 }
-function FromTuple12(schema, references, path14, value) {
-  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path14, schema.items.map((schema2, index) => Visit11(schema2, references, `${path14}/${index}`, value[index]))) : Default3(schema, path14, value);
+function FromTuple12(schema, references, path13, value) {
+  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path13, schema.items.map((schema2, index) => Visit11(schema2, references, `${path13}/${index}`, value[index]))) : Default3(schema, path13, value);
 }
-function FromUnion17(schema, references, path14, value) {
+function FromUnion17(schema, references, path13, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const decoded = Visit11(subschema, references, path14, value);
-    return Default3(schema, path14, decoded);
+    const decoded = Visit11(subschema, references, path13, value);
+    return Default3(schema, path13, decoded);
   }
-  return Default3(schema, path14, value);
+  return Default3(schema, path13, value);
 }
-function Visit11(schema, references, path14, value) {
+function Visit11(schema, references, path13, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray14(schema_, references_, path14, value);
+      return FromArray14(schema_, references_, path13, value);
     case "Import":
-      return FromImport7(schema_, references_, path14, value);
+      return FromImport7(schema_, references_, path13, value);
     case "Intersect":
-      return FromIntersect15(schema_, references_, path14, value);
+      return FromIntersect15(schema_, references_, path13, value);
     case "Not":
-      return FromNot5(schema_, references_, path14, value);
+      return FromNot5(schema_, references_, path13, value);
     case "Object":
-      return FromObject15(schema_, references_, path14, value);
+      return FromObject15(schema_, references_, path13, value);
     case "Record":
-      return FromRecord10(schema_, references_, path14, value);
+      return FromRecord10(schema_, references_, path13, value);
     case "Ref":
-      return FromRef11(schema_, references_, path14, value);
+      return FromRef11(schema_, references_, path13, value);
     case "Symbol":
-      return Default3(schema_, path14, value);
+      return Default3(schema_, path13, value);
     case "This":
-      return FromThis7(schema_, references_, path14, value);
+      return FromThis7(schema_, references_, path13, value);
     case "Tuple":
-      return FromTuple12(schema_, references_, path14, value);
+      return FromTuple12(schema_, references_, path13, value);
     case "Union":
-      return FromUnion17(schema_, references_, path14, value);
+      return FromUnion17(schema_, references_, path13, value);
     default:
-      return Default3(schema_, path14, value);
+      return Default3(schema_, path13, value);
   }
 }
 function TransformDecode(schema, references, value) {
@@ -7956,33 +7956,33 @@ var TransformEncodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformEncodeError = class extends TypeBoxError {
-  constructor(schema, path14, value, error) {
+  constructor(schema, path13, value, error) {
     super(`${error instanceof Error ? error.message : "Unknown error"}`);
     this.schema = schema;
-    this.path = path14;
+    this.path = path13;
     this.value = value;
     this.error = error;
   }
 };
-function Default4(schema, path14, value) {
+function Default4(schema, path13, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
-    throw new TransformEncodeError(schema, path14, value, error);
+    throw new TransformEncodeError(schema, path13, value, error);
   }
 }
-function FromArray15(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, value);
-  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path14}/${index}`, value2)) : defaulted;
+function FromArray15(schema, references, path13, value) {
+  const defaulted = Default4(schema, path13, value);
+  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path13}/${index}`, value2)) : defaulted;
 }
-function FromImport8(schema, references, path14, value) {
+function FromImport8(schema, references, path13, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Default4(schema, path14, value);
-  return Visit12(target, [...references, ...additional], path14, result);
+  const result = Default4(schema, path13, value);
+  return Visit12(target, [...references, ...additional], path13, result);
 }
-function FromIntersect16(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, value);
+function FromIntersect16(schema, references, path13, value) {
+  const defaulted = Default4(schema, path13, value);
   if (!IsObject2(value) || IsValueType(value))
     return defaulted;
   const knownEntries = KeyOfPropertyEntries(schema);
@@ -7990,7 +7990,7 @@ function FromIntersect16(schema, references, path14, value) {
   const knownProperties = { ...defaulted };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit12(knownSchema, references, `${path14}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit12(knownSchema, references, `${path13}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return knownProperties;
@@ -8000,15 +8000,15 @@ function FromIntersect16(schema, references, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(unevaluatedProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(unevaluatedProperties, `${path13}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot6(schema, references, path14, value) {
-  return Default4(schema.not, path14, Default4(schema, path14, value));
+function FromNot6(schema, references, path13, value) {
+  return Default4(schema.not, path13, Default4(schema, path13, value));
 }
-function FromObject16(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, value);
+function FromObject16(schema, references, path13, value) {
+  const defaulted = Default4(schema, path13, value);
   if (!IsObject2(defaulted))
     return defaulted;
   const knownKeys = KeyOfPropertyKeys(schema);
@@ -8018,7 +8018,7 @@ function FromObject16(schema, references, path14, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit12(schema.properties[key], references, `${path14}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit12(schema.properties[key], references, `${path13}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8028,12 +8028,12 @@ function FromObject16(schema, references, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path13}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord11(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, value);
+function FromRecord11(schema, references, path13, value) {
+  const defaulted = Default4(schema, path13, value);
   if (!IsObject2(value))
     return defaulted;
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -8041,7 +8041,7 @@ function FromRecord11(schema, references, path14, value) {
   const knownProperties = { ...defaulted };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path14}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path13}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8051,65 +8051,65 @@ function FromRecord11(schema, references, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path13}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef12(schema, references, path14, value) {
+function FromRef12(schema, references, path13, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path14, value);
-  return Default4(schema, path14, resolved);
+  const resolved = Visit12(target, references, path13, value);
+  return Default4(schema, path13, resolved);
 }
-function FromThis8(schema, references, path14, value) {
+function FromThis8(schema, references, path13, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path14, value);
-  return Default4(schema, path14, resolved);
+  const resolved = Visit12(target, references, path13, value);
+  return Default4(schema, path13, resolved);
 }
-function FromTuple13(schema, references, path14, value) {
-  const value1 = Default4(schema, path14, value);
-  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path14}/${index}`, value1[index])) : [];
+function FromTuple13(schema, references, path13, value) {
+  const value1 = Default4(schema, path13, value);
+  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path13}/${index}`, value1[index])) : [];
 }
-function FromUnion18(schema, references, path14, value) {
+function FromUnion18(schema, references, path13, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const value1 = Visit12(subschema, references, path14, value);
-    return Default4(schema, path14, value1);
+    const value1 = Visit12(subschema, references, path13, value);
+    return Default4(schema, path13, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit12(subschema, references, path14, value);
+    const value1 = Visit12(subschema, references, path13, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default4(schema, path14, value1);
+    return Default4(schema, path13, value1);
   }
-  return Default4(schema, path14, value);
+  return Default4(schema, path13, value);
 }
-function Visit12(schema, references, path14, value) {
+function Visit12(schema, references, path13, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray15(schema_, references_, path14, value);
+      return FromArray15(schema_, references_, path13, value);
     case "Import":
-      return FromImport8(schema_, references_, path14, value);
+      return FromImport8(schema_, references_, path13, value);
     case "Intersect":
-      return FromIntersect16(schema_, references_, path14, value);
+      return FromIntersect16(schema_, references_, path13, value);
     case "Not":
-      return FromNot6(schema_, references_, path14, value);
+      return FromNot6(schema_, references_, path13, value);
     case "Object":
-      return FromObject16(schema_, references_, path14, value);
+      return FromObject16(schema_, references_, path13, value);
     case "Record":
-      return FromRecord11(schema_, references_, path14, value);
+      return FromRecord11(schema_, references_, path13, value);
     case "Ref":
-      return FromRef12(schema_, references_, path14, value);
+      return FromRef12(schema_, references_, path13, value);
     case "This":
-      return FromThis8(schema_, references_, path14, value);
+      return FromThis8(schema_, references_, path13, value);
     case "Tuple":
-      return FromTuple13(schema_, references_, path14, value);
+      return FromTuple13(schema_, references_, path13, value);
     case "Union":
-      return FromUnion18(schema_, references_, path14, value);
+      return FromUnion18(schema_, references_, path13, value);
     default:
-      return Default4(schema_, path14, value);
+      return Default4(schema_, path13, value);
   }
 }
 function TransformEncode(schema, references, value) {
@@ -8377,18 +8377,18 @@ __export(pointer_exports, {
   ValuePointerRootSetError: () => ValuePointerRootSetError
 });
 var ValuePointerRootSetError = class extends TypeBoxError {
-  constructor(value, path14, update) {
+  constructor(value, path13, update) {
     super("Cannot set root value");
     this.value = value;
-    this.path = path14;
+    this.path = path13;
     this.update = update;
   }
 };
 var ValuePointerRootDeleteError = class extends TypeBoxError {
-  constructor(value, path14) {
+  constructor(value, path13) {
     super("Cannot delete root value");
     this.value = value;
-    this.path = path14;
+    this.path = path13;
   }
 };
 function Escape2(component) {
@@ -8532,82 +8532,82 @@ var ValueDiffError = class extends TypeBoxError {
     this.value = value;
   }
 };
-function CreateUpdate(path14, value) {
-  return { type: "update", path: path14, value };
+function CreateUpdate(path13, value) {
+  return { type: "update", path: path13, value };
 }
-function CreateInsert(path14, value) {
-  return { type: "insert", path: path14, value };
+function CreateInsert(path13, value) {
+  return { type: "insert", path: path13, value };
 }
-function CreateDelete(path14) {
-  return { type: "delete", path: path14 };
+function CreateDelete(path13) {
+  return { type: "delete", path: path13 };
 }
 function AssertDiffable(value) {
   if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
     throw new ValueDiffError(value, "Cannot diff objects with symbols");
 }
-function* ObjectType4(path14, current, next) {
+function* ObjectType4(path13, current, next) {
   AssertDiffable(current);
   AssertDiffable(next);
   if (!IsStandardObject(next))
-    return yield CreateUpdate(path14, next);
+    return yield CreateUpdate(path13, 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(`${path14}/${key}`, next[key]);
+    yield CreateInsert(`${path13}/${key}`, next[key]);
   }
   for (const key of currentKeys) {
     if (!HasPropertyKey2(next, key))
       continue;
     if (Equal(current, next))
       continue;
-    yield* Visit15(`${path14}/${key}`, current[key], next[key]);
+    yield* Visit15(`${path13}/${key}`, current[key], next[key]);
   }
   for (const key of currentKeys) {
     if (HasPropertyKey2(next, key))
       continue;
-    yield CreateDelete(`${path14}/${key}`);
+    yield CreateDelete(`${path13}/${key}`);
   }
 }
-function* ArrayType4(path14, current, next) {
+function* ArrayType4(path13, current, next) {
   if (!IsArray2(next))
-    return yield CreateUpdate(path14, next);
+    return yield CreateUpdate(path13, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path14}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
   }
   for (let i = 0; i < next.length; i++) {
     if (i < current.length)
       continue;
-    yield CreateInsert(`${path14}/${i}`, next[i]);
+    yield CreateInsert(`${path13}/${i}`, next[i]);
   }
   for (let i = current.length - 1; i >= 0; i--) {
     if (i < next.length)
       continue;
-    yield CreateDelete(`${path14}/${i}`);
+    yield CreateDelete(`${path13}/${i}`);
   }
 }
-function* TypedArrayType2(path14, current, next) {
+function* TypedArrayType2(path13, current, next) {
   if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-    return yield CreateUpdate(path14, next);
+    return yield CreateUpdate(path13, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path14}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
   }
 }
-function* ValueType2(path14, current, next) {
+function* ValueType2(path13, current, next) {
   if (current === next)
     return;
-  yield CreateUpdate(path14, next);
+  yield CreateUpdate(path13, next);
 }
-function* Visit15(path14, current, next) {
+function* Visit15(path13, current, next) {
   if (IsStandardObject(current))
-    return yield* ObjectType4(path14, current, next);
+    return yield* ObjectType4(path13, current, next);
   if (IsArray2(current))
-    return yield* ArrayType4(path14, current, next);
+    return yield* ArrayType4(path13, current, next);
   if (IsTypedArray(current))
-    return yield* TypedArrayType2(path14, current, next);
+    return yield* TypedArrayType2(path13, current, next);
   if (IsValueType(current))
-    return yield* ValueType2(path14, current, next);
+    return yield* ValueType2(path13, 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, path14, current, next) {
+function ObjectType5(root, path13, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path14, Clone2(next));
+    pointer_exports.Set(root, path13, Clone2(next));
   } else {
     const currentKeys = Object.getOwnPropertyNames(current);
     const nextKeys = Object.getOwnPropertyNames(next);
@@ -8681,43 +8681,43 @@ function ObjectType5(root, path14, current, next) {
       }
     }
     for (const nextKey of nextKeys) {
-      Visit16(root, `${path14}/${nextKey}`, current[nextKey], next[nextKey]);
+      Visit16(root, `${path13}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
-function ArrayType5(root, path14, current, next) {
+function ArrayType5(root, path13, current, next) {
   if (!IsArray2(current)) {
-    pointer_exports.Set(root, path14, Clone2(next));
+    pointer_exports.Set(root, path13, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path14}/${index}`, current[index], next[index]);
+      Visit16(root, `${path13}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
-function TypedArrayType3(root, path14, current, next) {
+function TypedArrayType3(root, path13, 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, path14, Clone2(next));
+    pointer_exports.Set(root, path13, Clone2(next));
   }
 }
-function ValueType3(root, path14, current, next) {
+function ValueType3(root, path13, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path14, next);
+  pointer_exports.Set(root, path13, next);
 }
-function Visit16(root, path14, current, next) {
+function Visit16(root, path13, current, next) {
   if (IsArray2(next))
-    return ArrayType5(root, path14, current, next);
+    return ArrayType5(root, path13, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path14, current, next);
+    return TypedArrayType3(root, path13, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path14, current, next);
+    return ObjectType5(root, path13, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path14, current, next);
+    return ValueType3(root, path13, current, next);
 }
 function IsNonMutableValue(value) {
   return IsTypedArray(value) || IsValueType(value);
@@ -8815,9 +8815,10 @@ __export(value_exports2, {
 });
 
 // src/lib/types.ts
-var CURRENT_REGISTRY_VERSION = 1;
+var CURRENT_REGISTRY_VERSION = 2;
 var CAPSULE_VERSION = 1;
 var MAX_POST_ERROR_LENGTH = 500;
+var MAX_NAME_LENGTH = 100;
 var DOCTOR_ALL_COOLDOWN_MS = 60 * 60 * 1e3;
 var DOCTOR_PER_TOPIC_CAP_MS = 24 * 60 * 60 * 1e3;
 var INACTIVE_AFTER_DAYS = 7;
@@ -8842,6 +8843,7 @@ var TopicEntrySchema = Type.Object({
   groupId: Type.String({ pattern: "^-?\\d+$" }),
   threadId: Type.String({ pattern: "^\\d+$" }),
   slug: Type.String({ pattern: "^[a-z][a-z0-9-]{0,49}$" }),
+  name: Type.String({ minLength: 1, maxLength: MAX_NAME_LENGTH }),
   type: TopicTypeSchema,
   status: TopicStatusSchema,
   capsuleVersion: Type.Integer({ minimum: 1 }),
@@ -8880,6 +8882,12 @@ var BASE_FILES = [
 function topicKey(groupId, threadId) {
   return `${groupId}:${threadId}`;
 }
+function generateSlug(threadId, groupId, existingSlugs) {
+  const base = `t-${threadId}`;
+  if (!existingSlugs.has(base)) return base;
+  const suffix = groupId.replace(/^-/, "").slice(-4);
+  return `t-${threadId}-${suffix}`;
+}
 
 // src/lib/registry.ts
 var REGISTRY_FILENAME = "topics.json";
@@ -8890,8 +8898,17 @@ function registryPath(workspaceDir) {
   return path.join(workspaceDir, "projects", REGISTRY_FILENAME);
 }
 var migrations = {
-  // Add migrations here as needed:
-  // '1_to_2': (data) => { ... return data; },
+  "1_to_2": (data) => {
+    const topics = data["topics"];
+    if (topics && typeof topics === "object" && !Array.isArray(topics)) {
+      for (const entry of Object.values(topics)) {
+        if (!entry["name"] && typeof entry["slug"] === "string") {
+          entry["name"] = entry["slug"];
+        }
+      }
+    }
+    return data;
+  }
 };
 function migrateRegistry(data) {
   const rawVersion = data["version"];
@@ -8994,13 +9011,6 @@ async function withRegistry(workspaceDir, fn) {
 import * as crypto from "node:crypto";
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
-var SLUG_RE = /^[a-z][a-z0-9-]{0,49}$/;
-function validateSlug(slug) {
-  return SLUG_RE.test(slug);
-}
-function sanitizeSlug(title) {
-  return title.toLowerCase().replace(/\./g, "").replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
 function jailCheck(base, userPath) {
   const resolved = path2.resolve(base, userPath);
   const normalizedBase = path2.resolve(base) + path2.sep;
@@ -9045,21 +9055,21 @@ function validateGroupId(id) {
 function validateThreadId(id) {
   return THREAD_ID_RE.test(id);
 }
-var CALLBACK_RE = /^tm:[a-z0-9]+:[a-z0-9-]+:-?\d+:\d+:[a-f0-9]+$/;
-function buildCallbackData(action, slug, groupId, threadId, secret) {
-  const payload = `tm:${action}:${slug}:${groupId}:${threadId}`;
+var CALLBACK_RE = /^tm:[a-z0-9]+:-?\d+:\d+:[a-f0-9]+$/;
+function buildCallbackData(action, groupId, threadId, secret) {
+  const payload = `tm:${action}:${groupId}:${threadId}`;
   const sig = hmacSign(secret, payload);
   return `${payload}:${sig}`;
 }
 function parseAndVerifyCallback(data, secret, contextGroupId, contextThreadId) {
   if (!CALLBACK_RE.test(data)) return null;
   const parts = data.split(":");
-  if (parts.length !== 6) return null;
-  const [, action, slug, groupId, threadId, signature] = parts;
+  if (parts.length !== 5) return null;
+  const [, action, groupId, threadId, signature] = parts;
   if (groupId !== contextGroupId || threadId !== contextThreadId) return null;
-  const payload = `tm:${action}:${slug}:${groupId}:${threadId}`;
+  const payload = `tm:${action}:${groupId}:${threadId}`;
   if (!hmacVerify(secret, payload, signature)) return null;
-  return { action, slug, groupId, threadId };
+  return { action, groupId, threadId };
 }
 
 // src/lib/audit.ts
@@ -9148,11 +9158,11 @@ function checkAuthorization(userId, command, registry, topicAllowFrom) {
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
 var BASE_TEMPLATES = {
-  "README.md": (slug) => `# ${slug}
+  "README.md": (name) => `# ${name}
 
 _Describe what this topic is about._
 `,
-  "STATUS.md": (slug) => `# Status: ${slug}
+  "STATUS.md": (name) => `# Status: ${name}
 
 ## Last done (UTC)
 
@@ -9166,7 +9176,7 @@ _No work recorded yet._
 2. [T-2] _Define second task in TODO.md_
 3. [T-3] _Define third task in TODO.md_
 `,
-  "TODO.md": (slug) => `# TODO: ${slug}
+  "TODO.md": (name) => `# TODO: ${name}
 
 ## Backlog
 
@@ -9178,51 +9188,51 @@ _No work recorded yet._
 
 _None yet._
 `,
-  "COMMANDS.md": (slug) => `# Commands: ${slug}
+  "COMMANDS.md": (name) => `# Commands: ${name}
 
 _Build, deploy, test, and other commands for this topic. Kept here so they're not lost on reset._
 `,
-  "LINKS.md": (slug) => `# Links: ${slug}
+  "LINKS.md": (name) => `# Links: ${name}
 
 _URLs, paths, and service endpoints for this topic._
 `,
-  "CRON.md": (slug) => `# Cron: ${slug}
+  "CRON.md": (name) => `# Cron: ${name}
 
 _Cron job IDs and schedules for this topic._
 `,
-  "NOTES.md": (slug) => `# Notes: ${slug}
+  "NOTES.md": (name) => `# Notes: ${name}
 
 _Anything worth remembering about this topic._
 `
 };
 var OVERLAY_TEMPLATES = {
-  "ARCHITECTURE.md": (slug) => `# Architecture: ${slug}
+  "ARCHITECTURE.md": (name) => `# Architecture: ${name}
 
 _Components, data flow, dependencies, and design decisions._
 `,
-  "DEPLOY.md": (slug) => `# Deployment: ${slug}
+  "DEPLOY.md": (name) => `# Deployment: ${name}
 
 _Environments, deployment steps, rollback procedures, and infra details._
 `,
-  "SOURCES.md": (slug) => `# Sources: ${slug}
+  "SOURCES.md": (name) => `# Sources: ${name}
 
 _Papers, articles, datasets, APIs, and other reference material._
 `,
-  "FINDINGS.md": (slug) => `# Findings: ${slug}
+  "FINDINGS.md": (name) => `# Findings: ${name}
 
 _Conclusions, insights, data summaries, and recommendations._
 `,
-  "CAMPAIGNS.md": (slug) => `# Campaigns: ${slug}
+  "CAMPAIGNS.md": (name) => `# Campaigns: ${name}
 
 _Active campaigns, target audiences, channels, timelines, and budgets._
 `,
-  "METRICS.md": (slug) => `# Metrics: ${slug}
+  "METRICS.md": (name) => `# Metrics: ${name}
 
 _KPIs, conversion rates, engagement stats, and performance data._
 `
 };
 var CAPSULE_FILE_MODE = 416;
-function scaffoldCapsule(projectsBase, slug, type) {
+function scaffoldCapsule(projectsBase, slug, name, type) {
   const capsuleDir = path4.join(projectsBase, slug);
   if (!jailCheck(projectsBase, slug)) {
     throw new Error(`Path escapes projects directory: ${slug}`);
@@ -9235,7 +9245,7 @@ function scaffoldCapsule(projectsBase, slug, type) {
     const templateFn = BASE_TEMPLATES[file];
     if (templateFn) {
       const filePath = path4.join(capsuleDir, file);
-      fs4.writeFileSync(filePath, templateFn(slug), { mode: CAPSULE_FILE_MODE });
+      fs4.writeFileSync(filePath, templateFn(name), { mode: CAPSULE_FILE_MODE });
     }
   }
   const overlays = OVERLAY_FILES[type];
@@ -9243,11 +9253,11 @@ function scaffoldCapsule(projectsBase, slug, type) {
     const templateFn = OVERLAY_TEMPLATES[file];
     if (templateFn) {
       const filePath = path4.join(capsuleDir, file);
-      fs4.writeFileSync(filePath, templateFn(slug), { mode: CAPSULE_FILE_MODE });
+      fs4.writeFileSync(filePath, templateFn(name), { mode: CAPSULE_FILE_MODE });
     }
   }
 }
-function upgradeCapsule(projectsBase, slug, type, currentVersion) {
+function upgradeCapsule(projectsBase, slug, name, type, currentVersion) {
   if (currentVersion >= CAPSULE_VERSION) {
     return { upgraded: false, newVersion: currentVersion, addedFiles: [] };
   }
@@ -9264,7 +9274,7 @@ function upgradeCapsule(projectsBase, slug, type, currentVersion) {
     if (!fs4.existsSync(filePath)) {
       const templateFn = BASE_TEMPLATES[file];
       if (templateFn) {
-        fs4.writeFileSync(filePath, templateFn(slug), { mode: CAPSULE_FILE_MODE });
+        fs4.writeFileSync(filePath, templateFn(name), { mode: CAPSULE_FILE_MODE });
         addedFiles.push(file);
       }
     }
@@ -9275,7 +9285,7 @@ function upgradeCapsule(projectsBase, slug, type, currentVersion) {
     if (!fs4.existsSync(filePath)) {
       const templateFn = OVERLAY_TEMPLATES[file];
       if (templateFn) {
-        fs4.writeFileSync(filePath, templateFn(slug), { mode: CAPSULE_FILE_MODE });
+        fs4.writeFileSync(filePath, templateFn(name), { mode: CAPSULE_FILE_MODE });
         addedFiles.push(file);
       }
     }
@@ -9292,8 +9302,8 @@ var TELEGRAM_MSG_LIMIT = 4096;
 function buildInlineKeyboard(rows) {
   return { inline_keyboard: rows };
 }
-function buildDoctorButtons(slug, groupId, threadId, secret) {
-  const cb = (action) => buildCallbackData(action, slug, groupId, threadId, secret);
+function buildDoctorButtons(groupId, threadId, secret) {
+  const cb = (action) => buildCallbackData(action, groupId, threadId, secret);
   return buildInlineKeyboard([
     [
       { text: "Fix", callback_data: cb("fix") },
@@ -9306,14 +9316,8 @@ function buildDoctorButtons(slug, groupId, threadId, secret) {
     ]
   ]);
 }
-function buildInitSlugButtons(slug, groupId, threadId, secret) {
-  const cb = (action) => buildCallbackData(action, slug, groupId, threadId, secret);
-  return buildInlineKeyboard([
-    [{ text: "Confirm", callback_data: cb("is") }]
-  ]);
-}
-function buildInitTypeButtons(slug, groupId, threadId, secret) {
-  const cb = (action) => buildCallbackData(action, slug, groupId, threadId, secret);
+function buildInitTypeButtons(groupId, threadId, secret) {
+  const cb = (action) => buildCallbackData(action, groupId, threadId, secret);
   return buildInlineKeyboard([
     [
       { text: "Coding", callback_data: cb("ic") },
@@ -9325,12 +9329,13 @@ function buildInitTypeButtons(slug, groupId, threadId, secret) {
     ]
   ]);
 }
-function buildTopicCard(slug, type, capsuleVersion) {
+function buildTopicCard(name, slug, type, capsuleVersion) {
+  const n = htmlEscape(name);
   const s = htmlEscape(slug);
   const t = htmlEscape(type);
   const v = htmlEscape(String(capsuleVersion));
   return [
-    `<b>Topic: ${s}</b>`,
+    `<b>Topic: ${n}</b>`,
     `Type: ${t} | Version: ${v}`,
     `Capsule: projects/${s}/`,
     "",
@@ -9343,9 +9348,9 @@ function buildTopicCard(slug, type, capsuleVersion) {
     "/tm help \u2014 command reference"
   ].join("\n");
 }
-function buildDoctorReport(slug, results) {
-  const s = htmlEscape(slug);
-  const lines = [`<b>Doctor: ${s}</b>`, ""];
+function buildDoctorReport(name, results) {
+  const n = htmlEscape(name);
+  const lines = [`<b>Doctor: ${n}</b>`, ""];
   if (results.length === 0) {
     lines.push("All checks passed.");
     return lines.join("\n");
@@ -9385,7 +9390,7 @@ function buildHelpCard() {
     "/tm status \u2014 quick STATUS.md view",
     "/tm list \u2014 show all topics",
     "/tm sync \u2014 re-apply config",
-    "/tm rename &lt;slug&gt; \u2014 rename topic",
+    "/tm rename &lt;name&gt; \u2014 rename topic",
     "/tm upgrade \u2014 update capsule template",
     "/tm snooze &lt;Nd&gt; \u2014 snooze doctor (7d, 30d, etc.)",
     "/tm archive \u2014 archive topic",
@@ -9405,7 +9410,7 @@ function buildListMessage(topics) {
   let rendered = 0;
   for (const t of sorted) {
     const entry = [
-      `<code>${htmlEscape(t.slug)}</code> [${htmlEscape(t.type)}] ${htmlEscape(t.status)}`,
+      `<b>${htmlEscape(t.name)}</b> [${htmlEscape(t.type)}] ${htmlEscape(t.status)}`,
       `  Last active: ${t.lastMessageAt ? relativeTime(t.lastMessageAt) : "never"}`,
       `  Thread: #${htmlEscape(t.threadId)}`
     ].join("\n");
@@ -9449,8 +9454,8 @@ import * as fs5 from "node:fs";
 import * as path5 from "node:path";
 var INCLUDE_FILENAME = "telegram-manager.generated.groups.json5";
 var FILE_MODE3 = 384;
-function getSystemPromptTemplate(slug, absoluteWorkspacePath) {
-  return `You are the assistant for the Telegram topic: ${slug}.
+function getSystemPromptTemplate(name, slug, absoluteWorkspacePath) {
+  return `You are the assistant for the Telegram topic: ${name}.
 
 Determinism rules:
 - Source of truth is the project capsule at: ${absoluteWorkspacePath}/projects/${slug}/
@@ -9494,7 +9499,7 @@ function buildIncludeObject(registry, workspaceDir, existingInclude) {
     }
   }
   for (const entry of Object.values(registry.topics)) {
-    const { groupId, threadId, slug, type, status } = entry;
+    const { groupId, threadId, slug, name, type, status } = entry;
     if (!groups[groupId]) {
       groups[groupId] = { topics: {} };
     }
@@ -9503,7 +9508,7 @@ function buildIncludeObject(registry, workspaceDir, existingInclude) {
     }
     const isEnabled = status !== "archived";
     const skills = getSkillsForType(type);
-    const systemPrompt = getSystemPromptTemplate(slug, absoluteWorkspacePath);
+    const systemPrompt = getSystemPromptTemplate(name, slug, absoluteWorkspacePath);
     groups[groupId].topics[threadId] = {
       enabled: isEnabled,
       skills,
@@ -9693,60 +9698,42 @@ async function handleInit(ctx, args) {
   const key = topicKey(groupId, threadId);
   if (registry.topics[key]) {
     return {
-      text: `This topic is already registered as <code>${htmlEscape(registry.topics[key].slug)}</code>.`,
+      text: `This topic is already registered as <b>${htmlEscape(registry.topics[key].name)}</b>.`,
       parseMode: "HTML"
     };
   }
   const parts = args.trim().split(/\s+/);
-  let slugArg = parts[0] ?? "";
-  let typeArg = parts[1] ?? "";
+  let nameArg = "";
+  let topicType = "coding";
+  if (parts.length > 0 && parts[parts.length - 1] && VALID_TYPES.has(parts[parts.length - 1].toLowerCase())) {
+    topicType = parts.pop().toLowerCase();
+    nameArg = parts.join(" ");
+  } else {
+    nameArg = parts.join(" ");
+  }
   const topicTitle = messageContext?.["topicTitle"] ?? "";
-  let slug;
-  if (slugArg) {
-    slug = slugArg;
+  let name;
+  if (nameArg) {
+    name = nameArg;
   } else if (topicTitle) {
-    slug = sanitizeSlug(topicTitle);
+    name = topicTitle;
   } else {
-    slug = `topic-${threadId}`;
-  }
-  if (slug && !/^[a-z]/.test(slug)) {
-    slug = "t-" + slug;
+    name = `Topic ${threadId}`;
   }
-  if (!validateSlug(slug)) {
-    return {
-      text: `Invalid slug "${htmlEscape(slug)}". Must start with a letter, lowercase alphanumeric + hyphens, max 50 chars.`
-    };
-  }
-  let topicType = "coding";
-  if (typeArg && VALID_TYPES.has(typeArg.toLowerCase())) {
-    topicType = typeArg.toLowerCase();
+  if (name.length > MAX_NAME_LENGTH) {
+    name = name.slice(0, MAX_NAME_LENGTH);
   }
+  const existingSlugs = new Set(Object.values(registry.topics).map((t) => t.slug));
+  const finalSlug = generateSlug(threadId, groupId, existingSlugs);
   const projectsBase = path6.join(workspaceDir, "projects");
-  if (!jailCheck(projectsBase, slug)) {
+  if (!jailCheck(projectsBase, finalSlug)) {
     return { text: "Path safety check failed. Slug may escape the projects directory." };
   }
   if (rejectSymlink(projectsBase)) {
     return { text: "Projects base is a symlink. Aborting for security." };
   }
-  const slugInUse = Object.values(registry.topics).some((t) => t.slug === slug);
-  const diskExists = fs6.existsSync(path6.join(projectsBase, slug));
-  let finalSlug = slug;
-  if (slugInUse || diskExists) {
-    const suffix = groupId.replace(/^-/, "").slice(-4);
-    finalSlug = `${slug}-${suffix}`.slice(0, 50);
-    if (!validateSlug(finalSlug)) {
-      return { text: `Could not generate a unique slug. Please provide one: /tm init &lt;slug&gt; [type]` };
-    }
-    const fallbackInUse = Object.values(registry.topics).some((t) => t.slug === finalSlug);
-    if (fallbackInUse) {
-      return {
-        text: `Both <code>${htmlEscape(slug)}</code> and <code>${htmlEscape(finalSlug)}</code> are taken. Please provide a unique slug: /tm init &lt;slug&gt; [type]`,
-        parseMode: "HTML"
-      };
-    }
-    if (!jailCheck(projectsBase, finalSlug)) {
-      return { text: "Path safety check failed for fallback slug." };
-    }
+  if (fs6.existsSync(path6.join(projectsBase, finalSlug))) {
+    return { text: `Directory projects/${htmlEscape(finalSlug)}/ already exists on disk.` };
   }
   const targetPath = path6.join(projectsBase, finalSlug);
   if (rejectSymlink(targetPath)) {
@@ -9755,11 +9742,12 @@ async function handleInit(ctx, args) {
   const isFirstUser = registry.topicManagerAdmins.length === 0;
   try {
     await withRegistry(workspaceDir, (data) => {
-      scaffoldCapsule(projectsBase, finalSlug, topicType);
+      scaffoldCapsule(projectsBase, finalSlug, name, topicType);
       const newEntry = {
         groupId,
         threadId,
         slug: finalSlug,
+        name,
         type: topicType,
         status: "active",
         capsuleVersion: CAPSULE_VERSION,
@@ -9799,38 +9787,27 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   }
   appendAudit(
     workspaceDir,
-    buildAuditEntry(userId, "init", finalSlug, `Initialized topic type=${topicType} group=${groupId} thread=${threadId}`)
+    buildAuditEntry(userId, "init", finalSlug, `Initialized topic name="${name}" type=${topicType} group=${groupId} thread=${threadId}`)
   );
-  const topicCard = buildTopicCard(finalSlug, topicType, CAPSULE_VERSION);
+  const topicCard = buildTopicCard(name, finalSlug, topicType, CAPSULE_VERSION);
   let adminNote = "";
   if (isFirstUser) {
     adminNote = "\n\nYou are the first user and have been added as a telegram-manager admin.";
   }
-  let slugNote = "";
-  if (finalSlug !== slug) {
-    slugNote = `
-
-Note: slug <code>${htmlEscape(slug)}</code> was taken, using <code>${htmlEscape(finalSlug)}</code> instead.`;
-  }
   return {
-    text: `${topicCard}${slugNote}${adminNote}${restartMsg}`,
+    text: `${topicCard}${adminNote}${restartMsg}`,
     parseMode: "HTML",
     pin: true
   };
 }
-var CALLBACK_BYTE_LIMIT = 64;
-function fitsCallbackLimit(action, slug, groupId, threadId, secret) {
-  const data = buildCallbackData(action, slug, groupId, threadId, secret);
-  return Buffer.byteLength(data, "utf-8") <= CALLBACK_BYTE_LIMIT;
-}
 async function handleInitInteractive(ctx, args) {
   if (args.trim()) {
     return handleInit(ctx, args);
   }
-  return buildSlugConfirmation(ctx);
+  return buildTypePicker(ctx);
 }
-async function buildSlugConfirmation(ctx) {
-  const { workspaceDir, userId, groupId, threadId, messageContext } = ctx;
+async function buildTypePicker(ctx) {
+  const { workspaceDir, userId, groupId, threadId } = ctx;
   if (!userId || !groupId || !threadId) {
     return { text: "Missing context: groupId, threadId, or userId not available. Run this command inside a Telegram forum topic." };
   }
@@ -9852,69 +9829,19 @@ async function buildSlugConfirmation(ctx) {
   const key = topicKey(groupId, threadId);
   if (registry.topics[key]) {
     return {
-      text: `This topic is already registered as <code>${htmlEscape(registry.topics[key].slug)}</code>.`,
-      parseMode: "HTML"
-    };
-  }
-  const topicTitle = messageContext?.["topicTitle"] ?? "";
-  let slug;
-  if (topicTitle) {
-    slug = sanitizeSlug(topicTitle);
-  } else {
-    slug = `topic-${threadId}`;
-  }
-  if (slug && !/^[a-z]/.test(slug)) {
-    slug = "t-" + slug;
-  }
-  if (!validateSlug(slug)) {
-    return {
-      text: `Invalid derived slug "${htmlEscape(slug)}". Please provide one: /tm init &lt;slug&gt; [type]`
-    };
-  }
-  if (!fitsCallbackLimit("is", slug, groupId, threadId, registry.callbackSecret)) {
-    return {
-      text: `Suggested slug: <code>${htmlEscape(slug)}</code>
-
-Slug is too long for inline buttons. Please run:
-<code>/tm init ${htmlEscape(slug)} [type]</code>`,
-      parseMode: "HTML"
-    };
-  }
-  const keyboard = buildInitSlugButtons(slug, groupId, threadId, registry.callbackSecret);
-  return {
-    text: `Initialize this topic as <code>${htmlEscape(slug)}</code>?`,
-    parseMode: "HTML",
-    inlineKeyboard: keyboard
-  };
-}
-async function handleInitSlugConfirm(ctx, slug) {
-  const { workspaceDir, userId, groupId, threadId } = ctx;
-  if (!userId || !groupId || !threadId) {
-    return { text: "Missing context." };
-  }
-  const registry = readRegistry(workspaceDir);
-  const auth = checkAuthorization(userId, "init", registry);
-  if (!auth.authorized) {
-    return { text: auth.message ?? "Not authorized." };
-  }
-  const key = topicKey(groupId, threadId);
-  if (registry.topics[key]) {
-    return {
-      text: `This topic is already registered as <code>${htmlEscape(registry.topics[key].slug)}</code>.`,
+      text: `This topic is already registered as <b>${htmlEscape(registry.topics[key].name)}</b>.`,
       parseMode: "HTML"
     };
   }
-  const keyboard = buildInitTypeButtons(slug, groupId, threadId, registry.callbackSecret);
+  const keyboard = buildInitTypeButtons(groupId, threadId, registry.callbackSecret);
   return {
-    text: `Slug: <code>${htmlEscape(slug)}</code>
-
-Pick a topic type:`,
+    text: "Pick a topic type:",
     parseMode: "HTML",
     inlineKeyboard: keyboard
   };
 }
-async function handleInitTypeSelect(ctx, slug, type) {
-  return handleInit(ctx, `${slug} ${type}`);
+async function handleInitTypeSelect(ctx, type) {
+  return handleInit(ctx, type);
 }
 
 // src/commands/doctor.ts
@@ -10335,9 +10262,8 @@ async function handleDoctor(ctx) {
     registry,
     cronJobsPath
   );
-  const reportText = buildDoctorReport(entry.slug, results);
+  const reportText = buildDoctorReport(entry.name, results);
   const keyboard = buildDoctorButtons(
-    entry.slug,
     groupId,
     threadId,
     registry.callbackSecret
@@ -10419,9 +10345,8 @@ async function handleDoctorAll(ctx) {
       if (isSpam) {
         logger.info(`[doctor-all] Auto-snoozing ${entry.slug} (${entry.consecutiveSilentDoctors} silent runs)`);
       }
-      const reportText = buildDoctorReport(entry.slug, results);
+      const reportText = buildDoctorReport(entry.name, results);
       const keyboard = buildDoctorButtons(
-        entry.slug,
         entry.groupId,
         entry.threadId,
         registry.callbackSecret
@@ -10619,21 +10544,17 @@ async function handleSync(ctx) {
 }
 
 // src/commands/rename.ts
-import * as fs11 from "node:fs";
-import * as path11 from "node:path";
-async function handleRename(ctx, newSlug) {
+async function handleRename(ctx, newName) {
   const { workspaceDir, configDir, userId, groupId, threadId, rpc, logger } = ctx;
   if (!userId || !groupId || !threadId) {
     return { text: "Missing context: userId, groupId, or threadId not available." };
   }
-  const trimmedSlug = newSlug.trim();
-  if (!trimmedSlug) {
-    return { text: "Usage: /tm rename &lt;new-slug&gt;" };
+  const trimmedName = newName.trim();
+  if (!trimmedName) {
+    return { text: "Usage: /tm rename &lt;new-name&gt;" };
   }
-  if (!validateSlug(trimmedSlug)) {
-    return {
-      text: `Invalid slug "${htmlEscape(trimmedSlug)}". Must match: lowercase letter start, alphanumeric + hyphens, max 50 chars.`
-    };
+  if (trimmedName.length > MAX_NAME_LENGTH) {
+    return { text: `Name too long (max ${MAX_NAME_LENGTH} characters).` };
   }
   const registry = readRegistry(workspaceDir);
   const auth = checkAuthorization(userId, "rename", registry);
@@ -10645,53 +10566,16 @@ async function handleRename(ctx, newSlug) {
   if (!entry) {
     return { text: "This topic is not registered. Run /tm init first." };
   }
-  const oldSlug = entry.slug;
-  if (oldSlug === trimmedSlug) {
-    return { text: `Topic is already named <code>${htmlEscape(oldSlug)}</code>.` };
-  }
-  const projectsBase = path11.join(workspaceDir, "projects");
-  if (!jailCheck(projectsBase, oldSlug)) {
-    return { text: "Path safety check failed for current slug." };
-  }
-  if (!jailCheck(projectsBase, trimmedSlug)) {
-    return { text: "Path safety check failed for new slug." };
-  }
-  const oldPath = path11.join(projectsBase, oldSlug);
-  const newPath = path11.join(projectsBase, trimmedSlug);
-  if (rejectSymlink(oldPath)) {
-    return { text: "Current capsule directory is a symlink. Aborting for security." };
-  }
-  if (rejectSymlink(newPath)) {
-    return { text: "Target capsule directory is a symlink. Aborting for security." };
-  }
-  const collisionInRegistry = Object.values(registry.topics).some((t) => t.slug === trimmedSlug);
-  if (collisionInRegistry) {
-    return {
-      text: `Slug <code>${htmlEscape(trimmedSlug)}</code> is already used by another topic.`,
-      parseMode: "HTML"
-    };
-  }
-  if (fs11.existsSync(newPath)) {
-    return {
-      text: `Directory projects/${htmlEscape(trimmedSlug)}/ already exists on disk.`,
-      parseMode: "HTML"
-    };
-  }
-  if (!fs11.existsSync(oldPath)) {
-    return { text: `Source capsule directory not found: projects/${htmlEscape(oldSlug)}/` };
-  }
-  try {
-    await withRegistry(workspaceDir, (data) => {
-      const topic = data.topics[key];
-      if (topic) {
-        fs11.renameSync(oldPath, newPath);
-        topic.slug = trimmedSlug;
-      }
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { text: `Failed to rename capsule: ${htmlEscape(msg)}` };
+  const oldName = entry.name;
+  if (oldName === trimmedName) {
+    return { text: `Topic is already named <b>${htmlEscape(oldName)}</b>.`, parseMode: "HTML" };
   }
+  await withRegistry(workspaceDir, (data) => {
+    const topic = data.topics[key];
+    if (topic) {
+      topic.name = trimmedName;
+    }
+  });
   let restartMsg = "";
   const configWritesEnabled = await getConfigWrites(ctx.rpc);
   if (configWritesEnabled) {
@@ -10710,11 +10594,11 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   }
   appendAudit(
     workspaceDir,
-    buildAuditEntry(userId, "rename", trimmedSlug, `Renamed from ${oldSlug} to ${trimmedSlug}`)
+    buildAuditEntry(userId, "rename", entry.slug, `Renamed from "${oldName}" to "${trimmedName}"`)
   );
-  const topicCard = buildTopicCard(trimmedSlug, entry.type, entry.capsuleVersion);
+  const topicCard = buildTopicCard(trimmedName, entry.slug, entry.type, entry.capsuleVersion);
   return {
-    text: `Topic renamed from <code>${htmlEscape(oldSlug)}</code> to <code>${htmlEscape(trimmedSlug)}</code>.
+    text: `Topic renamed from <b>${htmlEscape(oldName)}</b> to <b>${htmlEscape(trimmedName)}</b>.
 
 ${topicCard}${restartMsg}`,
     parseMode: "HTML"
@@ -10722,7 +10606,7 @@ ${topicCard}${restartMsg}`,
 }
 
 // src/commands/upgrade.ts
-import * as path12 from "node:path";
+import * as path11 from "node:path";
 async function handleUpgrade(ctx) {
   const { workspaceDir, userId, groupId, threadId } = ctx;
   if (!userId || !groupId || !threadId) {
@@ -10740,15 +10624,15 @@ async function handleUpgrade(ctx) {
   }
   if (entry.capsuleVersion >= CAPSULE_VERSION) {
     return {
-      text: `Topic <code>${htmlEscape(entry.slug)}</code> is already at capsule version ${CAPSULE_VERSION}. No upgrade needed.`,
+      text: `Topic <b>${htmlEscape(entry.name)}</b> is already at capsule version ${CAPSULE_VERSION}. No upgrade needed.`,
       parseMode: "HTML"
     };
   }
-  const projectsBase = path12.join(workspaceDir, "projects");
-  const result = upgradeCapsule(projectsBase, entry.slug, entry.type, entry.capsuleVersion);
+  const projectsBase = path11.join(workspaceDir, "projects");
+  const result = upgradeCapsule(projectsBase, entry.slug, entry.name, entry.type, entry.capsuleVersion);
   if (!result.upgraded) {
     return {
-      text: `No upgrade needed for <code>${htmlEscape(entry.slug)}</code>.`,
+      text: `No upgrade needed for <b>${htmlEscape(entry.name)}</b>.`,
       parseMode: "HTML"
     };
   }
@@ -10761,7 +10645,7 @@ async function handleUpgrade(ctx) {
   const addedList = result.addedFiles.length > 0 ? `
 Added files: ${result.addedFiles.map((f) => htmlEscape(f)).join(", ")}` : "\nNo new files added.";
   return {
-    text: `Topic <code>${htmlEscape(entry.slug)}</code> upgraded from v${entry.capsuleVersion} to v${result.newVersion}.${addedList}`,
+    text: `Topic <b>${htmlEscape(entry.name)}</b> upgraded from v${entry.capsuleVersion} to v${result.newVersion}.${addedList}`,
     parseMode: "HTML"
   };
 }
@@ -10809,7 +10693,7 @@ async function handleSnooze(ctx, args) {
     buildAuditEntry(userId, "snooze", entry.slug, `Snoozed for ${days} days until ${snoozeUntil}`)
   );
   return {
-    text: `Topic <code>${htmlEscape(entry.slug)}</code> snoozed for ${days} days (until ${htmlEscape(snoozeUntil)}).`,
+    text: `Topic <b>${htmlEscape(entry.name)}</b> snoozed for ${days} days (until ${htmlEscape(snoozeUntil)}).`,
     parseMode: "HTML"
   };
 }
@@ -10838,10 +10722,10 @@ async function handleArchiveToggle(ctx, archive) {
     return { text: "This topic is not registered. Run /tm init first." };
   }
   if (archive && entry.status === "archived") {
-    return { text: `Topic <code>${htmlEscape(entry.slug)}</code> is already archived.` };
+    return { text: `Topic <b>${htmlEscape(entry.name)}</b> is already archived.`, parseMode: "HTML" };
   }
   if (!archive && entry.status !== "archived") {
-    return { text: `Topic <code>${htmlEscape(entry.slug)}</code> is not archived.` };
+    return { text: `Topic <b>${htmlEscape(entry.name)}</b> is not archived.`, parseMode: "HTML" };
   }
   const newStatus = archive ? "archived" : "active";
   await withRegistry(workspaceDir, (data) => {
@@ -10875,7 +10759,7 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   );
   const action = archive ? "archived" : "unarchived";
   return {
-    text: `Topic <code>${htmlEscape(entry.slug)}</code> ${action}.${restartMsg}`,
+    text: `Topic <b>${htmlEscape(entry.name)}</b> ${action}.${restartMsg}`,
     parseMode: "HTML"
   };
 }
@@ -11006,23 +10890,20 @@ async function handleCallback(data, ctx) {
   if (!parsed) {
     return { text: "Invalid or expired callback." };
   }
-  const { action, slug } = parsed;
+  const { action } = parsed;
   const initTypeMap = {
     ic: "coding",
     ir: "research",
     im: "marketing",
     ix: "custom"
   };
-  if (action === "is") {
-    return handleInitSlugConfirm(ctx, slug);
-  }
   if (action in initTypeMap) {
-    return handleInitTypeSelect(ctx, slug, initTypeMap[action]);
+    return handleInitTypeSelect(ctx, initTypeMap[action]);
   }
   const key = topicKey(groupId, threadId);
   const entry = registry.topics[key];
-  if (!entry || entry.slug !== slug) {
-    return { text: "Topic not found or slug mismatch." };
+  if (!entry) {
+    return { text: "Topic not found." };
   }
   switch (action) {
     case "fix":
@@ -11056,25 +10937,25 @@ async function handleCallbackFix(ctx) {
 // src/index.ts
 function resolveConfigDir() {
   const thisFile = new URL(import.meta.url).pathname;
-  const parts = thisFile.split(path13.sep);
+  const parts = thisFile.split(path12.sep);
   const extIndex = parts.lastIndexOf("extensions");
   if (extIndex > 0) {
-    const candidate = parts.slice(0, extIndex).join(path13.sep);
-    if (fs12.existsSync(path13.join(candidate, "openclaw.json")) || fs12.existsSync(path13.join(candidate, "extensions"))) {
+    const candidate = parts.slice(0, extIndex).join(path12.sep);
+    if (fs11.existsSync(path12.join(candidate, "openclaw.json")) || fs11.existsSync(path12.join(candidate, "extensions"))) {
       return candidate;
     }
   }
   const envDir = process.env["OPENCLAW_CONFIG_DIR"];
-  if (envDir && fs12.existsSync(envDir)) return path13.resolve(envDir);
+  if (envDir && fs11.existsSync(envDir)) return path12.resolve(envDir);
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const defaultDir = path13.join(homeDir, ".openclaw");
-  if (fs12.existsSync(defaultDir)) return defaultDir;
+  const defaultDir = path12.join(homeDir, ".openclaw");
+  if (fs11.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 ? path13.join(resolvedConfigDir, "workspace") : void 0);
+  const workspaceDir = api.workspaceDir ?? api.pluginConfig?.workspaceDir ?? (resolvedConfigDir ? path12.join(resolvedConfigDir, "workspace") : void 0);
   if (!configDir || !workspaceDir) {
     api.logger.error(
       "telegram-manager: configDir or workspaceDir not available. Plugin cannot initialize."
@@ -11092,7 +10973,7 @@ function register(api) {
     description: "Manage Telegram forum topics as deterministic workcells. Sub-commands: init, doctor, list, status, sync, rename, upgrade, snooze, archive, unarchive, help.",
     parameters: Type.Object({
       command: Type.String({
-        description: "Sub-command and arguments (e.g., 'init', 'doctor --all', 'rename new-slug')"
+        description: "Sub-command and arguments (e.g., 'init', 'doctor --all', 'rename new-name')"
       })
     }),
     async execute(id, params, context) {
@@ -11110,7 +10991,7 @@ function register(api) {
       requireAuth: false,
       async handler(ctx) {
         const userId = ctx.senderId;
-        const groupId = ctx.channel?.replace(/^telegram:(?:group:)?/, "").split(":topic:")[0] || void 0;
+        const groupId = ctx.from?.replace(/^telegram:(?:group:)?/, "").split(":topic:")[0] || void 0;
         const threadId = ctx.messageThreadId != null ? String(ctx.messageThreadId) : void 0;
         const execContext = {};
         if (userId) execContext.userId = userId;
@@ -11120,8 +11001,15 @@ function register(api) {
         const reply = {
           text: result.text
         };
+        const telegramData = {};
         if (result.inlineKeyboard) {
-          reply.channelData = { telegram: { buttons: result.inlineKeyboard } };
+          telegramData.buttons = result.inlineKeyboard.inline_keyboard;
+        }
+        if (result.parseMode) {
+          telegramData.parse_mode = result.parseMode;
+        }
+        if (Object.keys(telegramData).length > 0) {
+          reply.channelData = { telegram: telegramData };
         }
         return reply;
       }