canopycms-cdk 0.0.61 → 0.0.62

package/worker/dist/index.js

@@ -814,10 +814,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault2(require_src());
     var log7 = debug_1.default("@kwsites/file-exists");
-    function check(path13, isFile, isDirectory) {
-      log7(`checking %s`, path13);
+    function check(path15, isFile, isDirectory) {
+      log7(`checking %s`, path15);
       try {
-        const stat = fs_1.statSync(path13);
+        const stat = fs_1.statSync(path15);
         if (stat.isFile() && isFile) {
           log7(`[OK] path represents a file`);
           return true;
@@ -837,8 +837,8 @@ var require_src2 = __commonJS({
         throw e5;
       }
     }
-    function exists2(path13, type = exports.READABLE) {
-      return check(path13, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path15, type = exports.READABLE) {
+      return check(path15, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -927,54 +927,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs9) {
+    function patch(fs10) {
       if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs9);
-      }
-      if (!fs9.lutimes) {
-        patchLutimes(fs9);
-      }
-      fs9.chown = chownFix(fs9.chown);
-      fs9.fchown = chownFix(fs9.fchown);
-      fs9.lchown = chownFix(fs9.lchown);
-      fs9.chmod = chmodFix(fs9.chmod);
-      fs9.fchmod = chmodFix(fs9.fchmod);
-      fs9.lchmod = chmodFix(fs9.lchmod);
-      fs9.chownSync = chownFixSync(fs9.chownSync);
-      fs9.fchownSync = chownFixSync(fs9.fchownSync);
-      fs9.lchownSync = chownFixSync(fs9.lchownSync);
-      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
-      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
-      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
-      fs9.stat = statFix(fs9.stat);
-      fs9.fstat = statFix(fs9.fstat);
-      fs9.lstat = statFix(fs9.lstat);
-      fs9.statSync = statFixSync(fs9.statSync);
-      fs9.fstatSync = statFixSync(fs9.fstatSync);
-      fs9.lstatSync = statFixSync(fs9.lstatSync);
-      if (fs9.chmod && !fs9.lchmod) {
-        fs9.lchmod = function(path13, mode, cb) {
+        patchLchmod(fs10);
+      }
+      if (!fs10.lutimes) {
+        patchLutimes(fs10);
+      }
+      fs10.chown = chownFix(fs10.chown);
+      fs10.fchown = chownFix(fs10.fchown);
+      fs10.lchown = chownFix(fs10.lchown);
+      fs10.chmod = chmodFix(fs10.chmod);
+      fs10.fchmod = chmodFix(fs10.fchmod);
+      fs10.lchmod = chmodFix(fs10.lchmod);
+      fs10.chownSync = chownFixSync(fs10.chownSync);
+      fs10.fchownSync = chownFixSync(fs10.fchownSync);
+      fs10.lchownSync = chownFixSync(fs10.lchownSync);
+      fs10.chmodSync = chmodFixSync(fs10.chmodSync);
+      fs10.fchmodSync = chmodFixSync(fs10.fchmodSync);
+      fs10.lchmodSync = chmodFixSync(fs10.lchmodSync);
+      fs10.stat = statFix(fs10.stat);
+      fs10.fstat = statFix(fs10.fstat);
+      fs10.lstat = statFix(fs10.lstat);
+      fs10.statSync = statFixSync(fs10.statSync);
+      fs10.fstatSync = statFixSync(fs10.fstatSync);
+      fs10.lstatSync = statFixSync(fs10.lstatSync);
+      if (fs10.chmod && !fs10.lchmod) {
+        fs10.lchmod = function(path15, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs10.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path13, uid, gid, cb) {
+      if (fs10.chown && !fs10.lchown) {
+        fs10.lchown = function(path15, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs10.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs9.rename = typeof fs9.rename !== "function" ? fs9.rename : (function(fs$rename) {
+        fs10.rename = typeof fs10.rename !== "function" ? fs10.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() {
-                  fs9.stat(to, function(stater, st) {
+                  fs10.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -990,9 +990,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs9.rename);
+        })(fs10.rename);
       }
-      fs9.read = typeof fs9.read !== "function" ? fs9.read : (function(fs$read) {
+      fs10.read = typeof fs10.read !== "function" ? fs10.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -1000,22 +1000,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs9.read);
-      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs10.read);
+      fs10.readSync = typeof fs10.readSync !== "function" ? fs10.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs10, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -1025,11 +1025,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path13, mode, callback) {
-          fs10.open(
-            path13,
+      })(fs10.readSync);
+      function patchLchmod(fs11) {
+        fs11.lchmod = function(path15, mode, callback) {
+          fs11.open(
+            path15,
             constants2.O_WRONLY | constants2.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -1037,80 +1037,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs10.fchmod(fd, mode, function(err2) {
-                fs10.close(fd, function(err22) {
+              fs11.fchmod(fd, mode, function(err2) {
+                fs11.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs10.lchmodSync = function(path13, mode) {
-          var fd = fs10.openSync(path13, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+        fs11.lchmodSync = function(path15, mode) {
+          var fd = fs11.openSync(path15, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs10.fchmodSync(fd, mode);
+            ret = fs11.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs10.closeSync(fd);
+              fs11.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs10) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path13, at, mt, cb) {
-            fs10.open(path13, constants2.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs11) {
+        if (constants2.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
+          fs11.lutimes = function(path15, at, mt, cb) {
+            fs11.open(path15, constants2.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs10.futimes(fd, at, mt, function(er2) {
-                fs10.close(fd, function(er22) {
+              fs11.futimes(fd, at, mt, function(er2) {
+                fs11.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs10.lutimesSync = function(path13, at, mt) {
-            var fd = fs10.openSync(path13, constants2.O_SYMLINK);
+          fs11.lutimesSync = function(path15, at, mt) {
+            var fd = fs11.openSync(path15, constants2.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs10.futimesSync(fd, at, mt);
+              ret = fs11.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs10.closeSync(fd);
+                  fs11.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs10.futimes) {
-          fs10.lutimes = function(_a3, _b, _c5, cb) {
+        } else if (fs11.futimes) {
+          fs11.lutimes = function(_a3, _b, _c5, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs10.lutimesSync = function() {
+          fs11.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs9, target, mode, function(er) {
+          return orig.call(fs10, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -1120,7 +1120,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs9, target, mode);
+            return orig.call(fs10, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -1129,7 +1129,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs9, target, uid, gid, function(er) {
+          return orig.call(fs10, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -1139,7 +1139,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs9, target, uid, gid);
+            return orig.call(fs10, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -1159,13 +1159,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback);
+          return options ? orig.call(fs10, target, options, callback) : orig.call(fs10, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target);
+          var stats = options ? orig.call(fs10, target, options) : orig.call(fs10, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -1194,16 +1194,16 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs10) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path13, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
+      function ReadStream(path15, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path13;
+        this.path = path15;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -1237,7 +1237,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs10.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -1248,10 +1248,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path13, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path13, options);
+      function WriteStream(path15, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
         Stream.call(this);
-        this.path = path13;
+        this.path = path15;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -1276,7 +1276,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs9.open;
+          this._open = fs10.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -1311,7 +1311,7 @@ var require_clone = __commonJS({
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -1343,12 +1343,12 @@ var require_graceful_fs = __commonJS({
         m5 = "GFS4: " + m5.split(/\n/).join("\nGFS4: ");
         console.error(m5);
       };
-    if (!fs9[gracefulQueue]) {
+    if (!fs10[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs9, queue);
-      fs9.close = (function(fs$close) {
+      publishQueue(fs10, queue);
+      fs10.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs9, fd, function(err) {
+          return fs$close.call(fs10, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -1360,48 +1360,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs9.close);
-      fs9.closeSync = (function(fs$closeSync) {
+      })(fs10.close);
+      fs10.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs9, arguments);
+          fs$closeSync.apply(fs10, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs9.closeSync);
+      })(fs10.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs9[gracefulQueue]);
-          __require("assert").equal(fs9[gracefulQueue].length, 0);
+          debug2(fs10[gracefulQueue]);
+          __require("assert").equal(fs10[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs9[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs9));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
-      module.exports = patch(fs9);
-      fs9.__patched = true;
-    }
-    function patch(fs10) {
-      polyfills(fs10);
-      fs10.gracefulify = patch;
-      fs10.createReadStream = createReadStream;
-      fs10.createWriteStream = createWriteStream;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile;
-      function readFile(path13, options, cb) {
+      publishQueue(global, fs10[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs10));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs10.__patched) {
+      module.exports = patch(fs10);
+      fs10.__patched = true;
+    }
+    function patch(fs11) {
+      polyfills(fs11);
+      fs11.gracefulify = patch;
+      fs11.createReadStream = createReadStream;
+      fs11.createWriteStream = createWriteStream;
+      var fs$readFile = fs11.readFile;
+      fs11.readFile = readFile;
+      function readFile(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path13, options, cb);
-        function go$readFile(path14, options2, cb2, startTime) {
-          return fs$readFile(path14, options2, function(err) {
+        return go$readFile(path15, options, cb);
+        function go$readFile(path16, options2, cb2, startTime) {
+          return fs$readFile(path16, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path14, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path16, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1409,16 +1409,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile;
-      function writeFile(path13, data2, options, cb) {
+      var fs$writeFile = fs11.writeFile;
+      fs11.writeFile = writeFile;
+      function writeFile(path15, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path13, data2, options, cb);
-        function go$writeFile(path14, data3, options2, cb2, startTime) {
-          return fs$writeFile(path14, data3, options2, function(err) {
+        return go$writeFile(path15, data2, options, cb);
+        function go$writeFile(path16, data3, options2, cb2, startTime) {
+          return fs$writeFile(path16, data3, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path14, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path16, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1426,17 +1426,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs11.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
-      function appendFile(path13, data2, options, cb) {
+        fs11.appendFile = appendFile;
+      function appendFile(path15, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path13, data2, options, cb);
-        function go$appendFile(path14, data3, options2, cb2, startTime) {
-          return fs$appendFile(path14, data3, options2, function(err) {
+        return go$appendFile(path15, data2, options, cb);
+        function go$appendFile(path16, data3, options2, cb2, startTime) {
+          return fs$appendFile(path16, data3, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path14, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path16, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1444,9 +1444,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs10.copyFile;
+      var fs$copyFile = fs11.copyFile;
       if (fs$copyFile)
-        fs10.copyFile = copyFile;
+        fs11.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -1464,34 +1464,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs10.readdir;
-      fs10.readdir = readdir;
+      var fs$readdir = fs11.readdir;
+      fs11.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path13, options, cb) {
+      function readdir(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path14, options2, cb2, startTime) {
-          return fs$readdir(path14, fs$readdirCallback(
-            path14,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path14, options2, cb2, startTime) {
-          return fs$readdir(path14, options2, fs$readdirCallback(
-            path14,
+        } : function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, options2, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path13, options, cb);
-        function fs$readdirCallback(path14, options2, cb2, startTime) {
+        return go$readdir(path15, options, cb);
+        function fs$readdirCallback(path16, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path14, options2, cb2],
+                [path16, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -1506,21 +1506,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs10);
+        var legStreams = legacy(fs11);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs10.ReadStream;
+      var fs$ReadStream = fs11.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs10.WriteStream;
+      var fs$WriteStream = fs11.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs10, "ReadStream", {
+      Object.defineProperty(fs11, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -1530,7 +1530,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs11, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -1541,7 +1541,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs11, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -1552,7 +1552,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs11, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -1562,7 +1562,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path13, options) {
+      function ReadStream(path15, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -1582,7 +1582,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path13, options) {
+      function WriteStream(path15, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -1600,22 +1600,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path13, options) {
-        return new fs10.ReadStream(path13, options);
+      function createReadStream(path15, options) {
+        return new fs11.ReadStream(path15, options);
       }
-      function createWriteStream(path13, options) {
-        return new fs10.WriteStream(path13, options);
+      function createWriteStream(path15, options) {
+        return new fs11.WriteStream(path15, options);
       }
-      var fs$open = fs10.open;
-      fs10.open = open;
-      function open(path13, flags, mode, cb) {
+      var fs$open = fs11.open;
+      fs11.open = open;
+      function open(path15, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path13, flags, mode, cb);
-        function go$open(path14, flags2, mode2, cb2, startTime) {
-          return fs$open(path14, flags2, mode2, function(err, fd) {
+        return go$open(path15, flags, mode, cb);
+        function go$open(path16, flags2, mode2, cb2, startTime) {
+          return fs$open(path16, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path14, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path16, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1623,20 +1623,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs10;
+      return fs11;
     }
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs9[gracefulQueue].push(elem);
+      fs10[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i6 = 0; i6 < fs9[gracefulQueue].length; ++i6) {
-        if (fs9[gracefulQueue][i6].length > 2) {
-          fs9[gracefulQueue][i6][3] = now;
-          fs9[gracefulQueue][i6][4] = now;
+      for (var i6 = 0; i6 < fs10[gracefulQueue].length; ++i6) {
+        if (fs10[gracefulQueue][i6].length > 2) {
+          fs10[gracefulQueue][i6][3] = now;
+          fs10[gracefulQueue][i6][4] = now;
         }
       }
       retry2();
@@ -1644,9 +1644,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs9[gracefulQueue].length === 0)
+      if (fs10[gracefulQueue].length === 0)
         return;
-      var elem = fs9[gracefulQueue].shift();
+      var elem = fs10[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -1668,7 +1668,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs9[gracefulQueue].push(elem);
+          fs10[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -2103,10 +2103,10 @@ var require_mtime_precision = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
     "use strict";
     var cacheSymbol = Symbol();
-    function probe(file, fs9, callback) {
-      const cachedPrecision = fs9[cacheSymbol];
+    function probe(file, fs10, callback) {
+      const cachedPrecision = fs10[cacheSymbol];
       if (cachedPrecision) {
-        return fs9.stat(file, (err, stat) => {
+        return fs10.stat(file, (err, stat) => {
           if (err) {
             return callback(err);
           }
@@ -2114,16 +2114,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs9.utimes(file, mtime, mtime, (err) => {
+      fs10.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs9.stat(file, (err2, stat) => {
+        fs10.stat(file, (err2, stat) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs9, cacheSymbol, { value: precision });
+          Object.defineProperty(fs10, cacheSymbol, { value: precision });
           callback(null, stat.mtime, precision);
         });
       });
@@ -2144,8 +2144,8 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path13 = __require("path");
-    var fs9 = require_graceful_fs();
+    var path15 = __require("path");
+    var fs10 = require_graceful_fs();
     var retry2 = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -2155,7 +2155,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path13.resolve(file));
+        return callback(null, path15.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -2276,7 +2276,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs9,
+        fs: fs10,
         onCompromised: (err) => {
           throw err;
         },
@@ -2320,7 +2320,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs9,
+        fs: fs10,
         realpath: true,
         ...options
       };
@@ -2342,7 +2342,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs9,
+        fs: fs10,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -2381,16 +2381,16 @@ var require_lockfile = __commonJS({
 var require_adapter = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
     "use strict";
-    var fs9 = require_graceful_fs();
-    function createSyncFs(fs10) {
+    var fs10 = require_graceful_fs();
+    function createSyncFs(fs11) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs10 };
+      const newFs = { ...fs11 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs10[`${method}Sync`](...args);
+            ret = fs11[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -2428,7 +2428,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs9);
+      options.fs = createSyncFs(options.fs || fs10);
       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" });
       }
@@ -3785,15 +3785,15 @@ var require_dist_node9 = __commonJS({
         octokit.log.debug("request", options);
         const start = Date.now();
         const requestOptions = octokit.request.endpoint.parse(options);
-        const path13 = requestOptions.url.replace(options.baseUrl, "");
+        const path15 = requestOptions.url.replace(options.baseUrl, "");
         return request(options).then((response) => {
           octokit.log.info(
-            `${requestOptions.method} ${path13} - ${response.status} in ${Date.now() - start}ms`
+            `${requestOptions.method} ${path15} - ${response.status} in ${Date.now() - start}ms`
           );
           return response;
         }).catch((error2) => {
           octokit.log.info(
-            `${requestOptions.method} ${path13} - ${error2.status} in ${Date.now() - start}ms`
+            `${requestOptions.method} ${path15} - ${error2.status} in ${Date.now() - start}ms`
           );
           throw error2;
         });
@@ -7887,7 +7887,7 @@ var require_dist_node13 = __commonJS({
     ];
     function routeMatcher(paths) {
       const regexes = paths.map(
-        (path13) => path13.split("/").map((c7) => c7.startsWith("{") ? "(?:.+?)" : c7).join("/")
+        (path15) => path15.split("/").map((c7) => c7.startsWith("{") ? "(?:.+?)" : c7).join("/")
       );
       const regex2 = `^(?:${regexes.map((r6) => `(?:${r6})`).join("|")})[^/]*$`;
       return new RegExp(regex2, "i");
@@ -8089,7 +8089,6 @@ var init_types = __esm({
       "number",
       "boolean",
       "datetime",
-      "rich-text",
       "markdown",
       "mdx",
       "code"
@@ -8518,8 +8517,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data: data2, path: path13, errorMaps, issueData } = params;
-      const fullPath = [...path13, ...issueData.path || []];
+      const { data: data2, path: path15, errorMaps, issueData } = params;
+      const fullPath = [...path15, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -8827,11 +8826,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path13, key) {
+      constructor(parent, value, path15, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path13;
+        this._path = path15;
         this._key = key;
       }
       get path() {
@@ -12509,8 +12508,8 @@ var init_permissions = __esm({
 });
 
 // ../canopycms/src/paths/normalize.ts
-function normalizeFilesystemPath(path13) {
-  return path13.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path15) {
+  return path15.split(/[\\/]+/).filter(Boolean).join("/");
 }
 var init_normalize = __esm({
   "../canopycms/src/paths/normalize.ts"() {
@@ -12536,12 +12535,21 @@ var init_flatten = __esm({
   }
 });
 
+// ../canopycms/src/operating-mode/mode-env.ts
+var init_mode_env = __esm({
+  "../canopycms/src/operating-mode/mode-env.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // ../canopycms/src/config/validation.ts
 var init_validation = __esm({
   "../canopycms/src/config/validation.ts"() {
     "use strict";
     init_config2();
     init_flatten();
+    init_mode_env();
   }
 });
 
@@ -12594,6 +12602,7 @@ var init_operating_mode = __esm({
     init_client_safe_strategy();
     init_client_unsafe_strategy();
     init_deployment_name();
+    init_mode_env();
   }
 });
 
@@ -13650,9 +13659,9 @@ var init_createPaginator = __esm({
       command = withCommand(command) ?? command;
       return await client.send(command, ...args);
     };
-    get = (fromObject, path13) => {
+    get = (fromObject, path15) => {
       let cursor2 = fromObject;
-      const pathComponents = path13.split(".");
+      const pathComponents = path15.split(".");
       for (const step of pathComponents) {
         if (!cursor2 || typeof cursor2 !== "object") {
           return void 0;
@@ -14670,12 +14679,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path13 = request.path;
+          let path15 = request.path;
           if (queryString) {
-            path13 += `?${queryString}`;
+            path15 += `?${queryString}`;
           }
           if (request.fragment) {
-            path13 += `#${request.fragment}`;
+            path15 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -14687,7 +14696,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path13,
+            path: path15,
             port: request.port,
             agent,
             auth
@@ -14970,16 +14979,16 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             reject(err);
           };
           const queryString = querystringBuilder.buildQueryString(query || {});
-          let path13 = request.path;
+          let path15 = request.path;
           if (queryString) {
-            path13 += `?${queryString}`;
+            path15 += `?${queryString}`;
           }
           if (request.fragment) {
-            path13 += `#${request.fragment}`;
+            path15 += `#${request.fragment}`;
           }
           const req = session.request({
             ...request.headers,
-            [http2.constants.HTTP2_HEADER_PATH]: path13,
+            [http2.constants.HTTP2_HEADER_PATH]: path15,
             [http2.constants.HTTP2_HEADER_METHOD]: method
           });
           session.ref();
@@ -15166,13 +15175,13 @@ var require_dist_cjs14 = __commonJS({
           const abortError = buildAbortError(abortSignal);
           return Promise.reject(abortError);
         }
-        let path13 = request.path;
+        let path15 = request.path;
         const queryString = querystringBuilder.buildQueryString(request.query || {});
         if (queryString) {
-          path13 += `?${queryString}`;
+          path15 += `?${queryString}`;
         }
         if (request.fragment) {
-          path13 += `#${request.fragment}`;
+          path15 += `#${request.fragment}`;
         }
         let auth = "";
         if (request.username != null || request.password != null) {
@@ -15181,7 +15190,7 @@ var require_dist_cjs14 = __commonJS({
           auth = `${username}:${password}@`;
         }
         const { port, method } = request;
-        const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path13}`;
+        const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path15}`;
         const body = method === "GET" || method === "HEAD" ? void 0 : request.body;
         const requestOptions = {
           body,
@@ -17413,13 +17422,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path13, preserveJsx) {
-  if (typeof path13 === "string" && /^\.\.?\//.test(path13)) {
-    return path13.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m5, tsx, d5, ext, cm) {
+function __rewriteRelativeImportExtension(path15, preserveJsx) {
+  if (typeof path15 === "string" && /^\.\.?\//.test(path15)) {
+    return path15.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m5, tsx, d5, ext, cm) {
       return tsx ? preserveJsx ? ".jsx" : ".js" : d5 && (!ext || !cm) ? m5 : d5 + ext + "." + cm.toLowerCase() + "js";
     });
   }
-  return path13;
+  return path15;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -18317,11 +18326,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path13, search] = opTraits.http[1].split("?");
+            const [path15, search] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path13;
+              request.path = path15;
             } else {
-              request.path += path13;
+              request.path += path15;
             }
             const traitSearchParams = new URLSearchParams(search ?? "");
             Object.assign(query, Object.fromEntries(traitSearchParams));
@@ -18724,8 +18733,8 @@ var init_requestBuilder = __esm({
         return this;
       }
       p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
-        this.resolvePathStack.push((path13) => {
-          this.path = resolvedPath(path13, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
+        this.resolvePathStack.push((path15) => {
+          this.path = resolvedPath(path15, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
         });
         return this;
       }
@@ -19375,18 +19384,18 @@ var require_dist_cjs20 = __commonJS({
       }
     };
     var booleanEquals = (value1, value2) => value1 === value2;
-    var getAttrPathList = (path13) => {
-      const parts = path13.split(".");
+    var getAttrPathList = (path15) => {
+      const parts = path15.split(".");
       const pathList = [];
       for (const part of parts) {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
           if (part.indexOf("]") !== part.length - 1) {
-            throw new EndpointError(`Path: '${path13}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path15}' does not end with ']'`);
           }
           const arrayIndex = part.slice(squareBracketIndex + 1, -1);
           if (Number.isNaN(parseInt(arrayIndex))) {
-            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path13}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path15}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -19398,9 +19407,9 @@ var require_dist_cjs20 = __commonJS({
       }
       return pathList;
     };
-    var getAttr = (value, path13) => getAttrPathList(path13).reduce((acc, index) => {
+    var getAttr = (value, path15) => getAttrPathList(path15).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path13}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path15}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         return acc[parseInt(index)];
       }
@@ -19419,8 +19428,8 @@ var require_dist_cjs20 = __commonJS({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path13 = "", query = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path13}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path15 = "", query = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path15}`);
             url.search = Object.entries(query).map(([k6, v5]) => `${k6}=${v5}`).join("&");
             return url;
           }
@@ -20865,10 +20874,10 @@ ${longDate}
 ${credentialScope}
 ${utilHexEncoding.toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path13 }) {
+      getCanonicalPath({ path: path15 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path13.split("/")) {
+          for (const pathSegment of path15.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -20879,11 +20888,11 @@ ${utilHexEncoding.toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path13?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path13?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path15?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path15?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = utilUriEscape.escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path13;
+        return path15;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -22187,11 +22196,11 @@ var init_SmithyRpcV2CborProtocol = __esm({
           }
         }
         const { service, operation: operation2 } = (0, import_util_middleware5.getSmithyContext)(context);
-        const path13 = `/service/${service}/operation/${operation2}`;
+        const path15 = `/service/${service}/operation/${operation2}`;
         if (request.path.endsWith("/")) {
-          request.path += path13.slice(1);
+          request.path += path15.slice(1);
         } else {
-          request.path += path13;
+          request.path += path15;
         }
         return request;
       }
@@ -27836,14 +27845,14 @@ var require_readFile = __commonJS({
     var promises_1 = __require("node:fs/promises");
     exports.filePromises = {};
     exports.fileIntercept = {};
-    var readFile = (path13, options) => {
-      if (exports.fileIntercept[path13] !== void 0) {
-        return exports.fileIntercept[path13];
+    var readFile = (path15, options) => {
+      if (exports.fileIntercept[path15] !== void 0) {
+        return exports.fileIntercept[path15];
       }
-      if (!exports.filePromises[path13] || options?.ignoreCache) {
-        exports.filePromises[path13] = (0, promises_1.readFile)(path13, "utf8");
+      if (!exports.filePromises[path15] || options?.ignoreCache) {
+        exports.filePromises[path15] = (0, promises_1.readFile)(path15, "utf8");
       }
-      return exports.filePromises[path13];
+      return exports.filePromises[path15];
     };
     exports.readFile = readFile;
   }
@@ -27856,7 +27865,7 @@ var require_dist_cjs33 = __commonJS({
     var getHomeDir = require_getHomeDir();
     var getSSOTokenFilepath = require_getSSOTokenFilepath();
     var getSSOTokenFromFile = require_getSSOTokenFromFile();
-    var path13 = __require("path");
+    var path15 = __require("path");
     var types = require_dist_cjs();
     var readFile = require_readFile();
     var ENV_PROFILE = "AWS_PROFILE";
@@ -27878,9 +27887,9 @@ var require_dist_cjs33 = __commonJS({
       ...data2.default && { default: data2.default }
     });
     var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
-    var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path13.join(getHomeDir.getHomeDir(), ".aws", "config");
+    var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path15.join(getHomeDir.getHomeDir(), ".aws", "config");
     var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
-    var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path13.join(getHomeDir.getHomeDir(), ".aws", "credentials");
+    var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path15.join(getHomeDir.getHomeDir(), ".aws", "credentials");
     var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
     var profileNameBlockList = ["__proto__", "profile __proto__"];
     var parseIni = (iniData) => {
@@ -27935,11 +27944,11 @@ var require_dist_cjs33 = __commonJS({
       const relativeHomeDirPrefix = "~/";
       let resolvedFilepath = filepath;
       if (filepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedFilepath = path13.join(homeDir, filepath.slice(2));
+        resolvedFilepath = path15.join(homeDir, filepath.slice(2));
       }
       let resolvedConfigFilepath = configFilepath;
       if (configFilepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedConfigFilepath = path13.join(homeDir, configFilepath.slice(2));
+        resolvedConfigFilepath = path15.join(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
         readFile.readFile(resolvedConfigFilepath, {
@@ -27978,8 +27987,8 @@ var require_dist_cjs33 = __commonJS({
       getFileRecord() {
         return readFile.fileIntercept;
       },
-      interceptFile(path14, contents) {
-        readFile.fileIntercept[path14] = Promise.resolve(contents);
+      interceptFile(path16, contents) {
+        readFile.fileIntercept[path16] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return getSSOTokenFromFile.tokenIntercept;
@@ -28304,8 +28313,8 @@ var require_dist_cjs36 = __commonJS({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path13 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path13}`;
+              const { protocol, hostname, port, path: path15 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path15}`;
             }
           }
           return endpoint;
@@ -36502,8 +36511,8 @@ var require_dist_cjs53 = __commonJS({
 });
 
 // ../canopycms/src/worker/cms-worker.ts
-import fs7 from "node:fs/promises";
-import path10 from "node:path";
+import fs8 from "node:fs/promises";
+import path12 from "node:path";
 
 // ../../node_modules/.pnpm/simple-git@3.36.0/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -37094,8 +37103,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path13) {
-  return (0, import_file_exists.exists)(path13, import_file_exists.FOLDER);
+function folderExists(path15) {
+  return (0, import_file_exists.exists)(path15, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -37497,8 +37506,8 @@ function checkIsRepoRootTask() {
     commands: commands5,
     format: "utf-8",
     onError,
-    parser(path13) {
-      return /^\.(git)?$/.test(path13.trim());
+    parser(path15) {
+      return /^\.(git)?$/.test(path15.trim());
     }
   };
 }
@@ -37932,11 +37941,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path13, line, preview] = input.split(NULL);
-    paths.add(path13);
-    (results[path13] = results[path13] || []).push({
+    const [path15, line, preview] = input.split(NULL);
+    paths.add(path15);
+    (results[path15] = results[path15] || []).push({
       line: asNumber(line),
-      path: path13,
+      path: path15,
       preview
     });
   });
@@ -38700,14 +38709,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path13, text) {
+function parseInit(bare, path15, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path13, false, result[1]);
+    return new InitSummary(bare, path15, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path13, true, result[1]);
+    return new InitSummary(bare, path15, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -38718,7 +38727,7 @@ function parseInit(bare, path13, text) {
       break;
     }
   }
-  return new InitSummary(bare, path13, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path15, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -38727,9 +38736,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path13, existing, gitDir) {
+      constructor(bare, path15, existing, gitDir) {
         this.bare = bare;
-        this.path = path13;
+        this.path = path15;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -38741,7 +38750,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path13, customArgs) {
+function initTask(bare = false, path15, customArgs) {
   const commands5 = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands5)) {
     commands5.splice(1, 0, bareCommand);
@@ -38750,7 +38759,7 @@ function initTask(bare = false, path13, customArgs) {
     commands: commands5,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands5.includes("--bare"), path13, text);
+      return parseInit(commands5.includes("--bare"), path15, text);
     }
   };
 }
@@ -39565,12 +39574,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path13, index, working_dir) {
-        this.path = path13;
+      constructor(path15, index, working_dir) {
+        this.path = path15;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path13) || [null, path13, path13];
+          const detail = fromPathRegex.exec(path15) || [null, path15, path15];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -39601,14 +39610,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data2(index, workingDir, path13) {
+  function data2(index, workingDir, path15) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path13);
+      handler(result, path15);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path13, index, workingDir));
+      result.files.push(new FileStatusSummary(path15, index, workingDir));
     }
   }
 }
@@ -39959,9 +39968,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path13, write) {
+      hashObject(path15, write) {
         return this._runTask(
-          hashObjectTask(path13, write === true),
+          hashObjectTask(path15, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -40315,8 +40324,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path13 = input.trim().replace(/^["']|["']$/g, "");
-  return path13 && normalize(path13);
+  const path15 = input.trim().replace(/^["']|["']$/g, "");
+  return path15 && normalize(path15);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -40601,8 +40610,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path13) {
-  return subModuleTask(["add", repo, path13]);
+function addSubModuleTask(repo, path15) {
+  return subModuleTask(["add", repo, path15]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -40916,8 +40925,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path13, then) {
-      return this._runTask(addSubModuleTask2(repo, path13), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path15, then) {
+      return this._runTask(addSubModuleTask2(repo, path15), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -42613,6 +42622,7 @@ var import_short_uuid = __toESM(require_dist3(), 1);
 var isValidId = isValidContentId;
 
 // ../canopycms/src/content-id-index.ts
+init_logger();
 function extractIdFromFilename(filename) {
   if (filename.startsWith(".")) {
     return null;
@@ -42733,6 +42743,16 @@ function isStaleLeaseRejection(message) {
 
 // ../canopycms/src/utils/provisioning-lock.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
+async function tryAcquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs7.mkdir(lockTargetDir2, { recursive: true });
+  return import_proper_lockfile2.default.lock(lockTargetDir2, {
+    lockfilePath: path9.join(lockTargetDir2, lockName),
+    retries: 0,
+    stale: 3e4
+  });
+}
 
 // ../canopycms/src/git-manager.ts
 var log4 = createDebugLogger({ prefix: "GitManager" });
@@ -42759,11 +42779,22 @@ var GITHUB_TRACKING_REF_PREFIX = "refs/remotes/github/";
 // ../canopycms/src/worker/cms-worker.ts
 init_deployment_name();
 
+// ../canopycms/src/utils/content-write-lock.ts
+import path10 from "node:path";
+var META_DIR2 = ".canopy-meta";
+var CONTENT_WRITE_LOCK_NAME = "content-write.lock";
+function lockTargetDir(branchRoot) {
+  return path10.join(path10.resolve(branchRoot), META_DIR2);
+}
+function tryAcquireContentWriteLock(branchRoot) {
+  return tryAcquireProvisioningLock(lockTargetDir(branchRoot), CONTENT_WRITE_LOCK_NAME);
+}
+
 // ../canopycms/src/worker/worker-status.ts
-import path9 from "node:path";
+import path11 from "node:path";
 var WORKER_STATUS_FILE = "worker-status.json";
 async function writeWorkerStatus(taskDir, report) {
-  const filePath = path9.join(taskDir, WORKER_STATUS_FILE);
+  const filePath = path11.join(taskDir, WORKER_STATUS_FILE);
   const stamped = { ...report, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await atomicWriteFile(filePath, JSON.stringify(stamped, null, 2));
 }
@@ -42858,15 +42889,15 @@ var CmsWorker = class {
     this.releaseLockFn = null;
     this.log = cmsTaskQueueLogger;
     this.octokit = createCanopyOctokit({ auth: config.githubToken });
-    this.taskDir = path10.join(config.workspacePath, ".tasks");
-    this.remoteGitPath = path10.join(config.workspacePath, "remote.git");
-    this.contentBranchesPath = path10.join(config.workspacePath, "content-branches");
+    this.taskDir = path12.join(config.workspacePath, ".tasks");
+    this.remoteGitPath = path12.join(config.workspacePath, "remote.git");
+    this.contentBranchesPath = path12.join(config.workspacePath, "content-branches");
     this.baseBranch = config.baseBranch ?? "main";
     this.sanitizedBaseBranch = sanitizeBranchName(this.baseBranch);
     this.maxTasksPerCycle = config.maxTasksPerCycle ?? 10;
     this.taskTimeoutMs = config.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT;
     this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES2;
-    this.lockFilePath = path10.join(config.workspacePath, ".tasks", ".worker-lock");
+    this.lockFilePath = path12.join(config.workspacePath, ".tasks", ".worker-lock");
     this.lockStaleMs = config.lockStaleMs ?? DEFAULT_LOCK_STALE_MS;
     this.contentRoot = config.contentRoot ?? "content";
   }
@@ -43017,7 +43048,7 @@ var CmsWorker = class {
    * negligible, but a host with a badly wrong clock could misjudge liveness.
    */
   async acquireLock() {
-    await fs7.mkdir(this.taskDir, { recursive: true });
+    await fs8.mkdir(this.taskDir, { recursive: true });
     try {
       this.releaseLockFn = await import_proper_lockfile3.default.lock(this.taskDir, {
         lockfilePath: this.lockFilePath,
@@ -43111,7 +43142,7 @@ var CmsWorker = class {
   async ensureRemoteGit() {
     let exists2;
     try {
-      await fs7.stat(this.remoteGitPath);
+      await fs8.stat(this.remoteGitPath);
       exists2 = true;
     } catch {
       exists2 = false;
@@ -43136,7 +43167,7 @@ var CmsWorker = class {
       workerLogError(
         `remote.git base branch verification failed after clone: ${getErrorMessage2(err)}`
       );
-      await fs7.rm(this.remoteGitPath, { recursive: true, force: true });
+      await fs8.rm(this.remoteGitPath, { recursive: true, force: true });
       throw new Error(
         `remote.git clone of ${this.config.githubOwner}/${this.config.githubRepo} has no branch '${this.baseBranch}' - the GitHub repository is empty or the base branch does not exist. Push an initial commit to '${this.baseBranch}' and restart the worker (systemd will retry automatically).`
       );
@@ -43352,7 +43383,7 @@ var CmsWorker = class {
     if (!branch) return;
     const branchPath = this.branchWorkspacePath(branch);
     try {
-      await fs7.stat(branchPath);
+      await fs8.stat(branchPath);
     } catch {
       return;
     }
@@ -43396,7 +43427,7 @@ var CmsWorker = class {
     if (!branch) return;
     const branchPath = this.branchWorkspacePath(branch);
     try {
-      await fs7.stat(branchPath);
+      await fs8.stat(branchPath);
     } catch {
       return;
     }
@@ -43432,7 +43463,7 @@ var CmsWorker = class {
    * is sanitized.
    */
   branchWorkspacePath(branchRefName) {
-    return path10.join(this.contentBranchesPath, sanitizeBranchName(branchRefName));
+    return path12.join(this.contentBranchesPath, sanitizeBranchName(branchRefName));
   }
   /**
    * What `remote.git` currently holds for `branchRef`, or null when this
@@ -43859,7 +43890,7 @@ var CmsWorker = class {
    */
   async hasPendingHistoryRewrite(branchName) {
     try {
-      const branchPath = path10.join(this.contentBranchesPath, sanitizeBranchName(branchName));
+      const branchPath = path12.join(this.contentBranchesPath, sanitizeBranchName(branchName));
       const metaFile = await BranchMetadataFileManager.loadOnly(branchPath);
       return typeof metaFile?.branch.historyRewrittenFrom === "string";
     } catch {
@@ -43902,6 +43933,7 @@ var CmsWorker = class {
         durationMs: Date.now() - cycleStartedAt,
         rebased: rebaseSummary.rebased,
         skippedDirty: rebaseSummary.skippedDirty,
+        skippedLocked: rebaseSummary.skippedLocked,
         failed: rebaseSummary.failed,
         tracked: trackedSummary
       };
@@ -43933,7 +43965,7 @@ var CmsWorker = class {
   async cleanupTrashedBranchDirs() {
     let entries;
     try {
-      entries = await fs7.readdir(this.contentBranchesPath);
+      entries = await fs8.readdir(this.contentBranchesPath);
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT") return 0;
       throw err;
@@ -43954,7 +43986,7 @@ var CmsWorker = class {
       }
       if (now - stampDate.getTime() < TRASH_RETENTION_MS) continue;
       try {
-        await fs7.rm(path10.join(this.contentBranchesPath, name), {
+        await fs8.rm(path12.join(this.contentBranchesPath, name), {
           recursive: true,
           force: true,
           maxRetries: 3,
@@ -43992,12 +44024,12 @@ var CmsWorker = class {
    * untouched rather than force-resolved.
    */
   async refreshBaseBranchWorkspace() {
-    const basePath32 = path10.join(this.contentBranchesPath, this.sanitizedBaseBranch);
-    const gitDir = path10.join(basePath32, ".git");
+    const basePath32 = path12.join(this.contentBranchesPath, this.sanitizedBaseBranch);
+    const gitDir = path12.join(basePath32, ".git");
     try {
       let gitDirStat;
       try {
-        gitDirStat = await fs7.stat(gitDir);
+        gitDirStat = await fs8.stat(gitDir);
       } catch {
         gitDirStat = null;
       }
@@ -44158,24 +44190,39 @@ var CmsWorker = class {
       workerLogWarn(`  Failed to record rebase failure for ${branchDir}: ${getErrorMessage2(err)}`);
     }
   }
+  /**
+   * Test-only seam: awaited inside `rebaseActiveBranches()`'s conflict round,
+   * after `git rebase` reported conflicted files and BEFORE the
+   * `checkout --theirs` resolution loop overwrites them. No-op in production.
+   *
+   * A test subclass overrides this to land a real `ContentStore` write at
+   * exactly the instant the rebase is mid-flight -- the window the old TOCTOU
+   * comment above the dirty check wrongly called safe -- without any sleeps or
+   * shell rendezvous. See the "Deterministic interleavings" testing pattern in
+   * docs/concurrency.md, and `ContentStore.afterPrePassForTesting()` for the
+   * same idiom on the write side.
+   */
+  async afterConflictDetectedForTesting() {
+  }
   async rebaseActiveBranches() {
     const rebased = [];
     const skippedDirty = [];
+    const skippedLocked = [];
     const failed = [];
     let branchDirs;
     try {
-      branchDirs = await fs7.readdir(this.contentBranchesPath);
+      branchDirs = await fs8.readdir(this.contentBranchesPath);
     } catch {
-      return { rebased, skippedDirty, failed };
+      return { rebased, skippedDirty, skippedLocked, failed };
     }
     for (const branchDir of branchDirs) {
       if (branchDir.startsWith(".") || branchDir === "branches.json") {
         continue;
       }
-      const branchPath = path10.join(this.contentBranchesPath, branchDir);
-      const gitDir = path10.join(branchPath, ".git");
+      const branchPath = path12.join(this.contentBranchesPath, branchDir);
+      const gitDir = path12.join(branchPath, ".git");
       try {
-        const stat = await fs7.stat(gitDir);
+        const stat = await fs8.stat(gitDir);
         if (!stat.isDirectory()) {
           workerLog(`  Skipping ${branchDir}: .git is not a directory`);
           continue;
@@ -44209,148 +44256,168 @@ var CmsWorker = class {
           config: ["core.editor=true"],
           unsafe: { allowUnsafeEditor: true }
         });
-        const dirtyCheck = await branchGit.status();
-        if (dirtyCheck.files.length > 0) {
-          workerLog(`  Skipping ${branchDir}: has uncommitted changes`);
-          skippedDirty.push(branchDir);
-          continue;
-        }
-        const branchRef = (await branchGit.revparse(["--abbrev-ref", "HEAD"])).trim();
-        const canPublish = branchRef.length > 0 && branchRef !== "HEAD";
-        if (canPublish && metaFile?.branch.historyRewrittenFrom) {
-          await this.reconcilePendingRewrite({
-            branchPath,
-            branchDir,
-            branchRef,
-            headSha: (await branchGit.revparse(["HEAD"])).trim(),
-            marker: metaFile.branch.historyRewrittenFrom
-          });
+        let releaseContentLock;
+        try {
+          releaseContentLock = await tryAcquireContentWriteLock(branchPath);
+        } catch (lockErr) {
+          if (isNodeError(lockErr) && lockErr.code === "ELOCKED") {
+            workerLog(`  Skipping ${branchDir}: content write in progress (retrying next cycle)`);
+            skippedLocked.push(branchDir);
+            continue;
+          }
+          throw lockErr;
         }
-        await branchGit.fetch("origin", this.baseBranch);
-        const fetchedBaseTip = (await branchGit.revparse(["FETCH_HEAD"])).trim();
-        const behindCount = parseInt(
-          (await branchGit.raw(["rev-list", "--count", `HEAD..${fetchedBaseTip}`])).trim(),
-          10
-        );
-        const meta = getBranchMetadataFileManager(branchPath, this.contentBranchesPath);
-        if (behindCount === 0) {
-          const currentMeta = await BranchMetadataFileManager.loadOnly(branchPath);
-          const conflictStatus = currentMeta?.branch.conflictStatus;
-          const conflictFiles = currentMeta?.branch.conflictFiles;
-          const conflictAlreadyClean = (conflictStatus === void 0 || conflictStatus === "clean") && (conflictFiles === void 0 || conflictFiles.length === 0);
-          const alreadyClean = conflictAlreadyClean && currentMeta?.branch.rebaseFailure === void 0;
-          if (alreadyClean) {
+        try {
+          const dirtyCheck = await branchGit.status();
+          if (dirtyCheck.files.length > 0) {
+            workerLog(`  Skipping ${branchDir}: has uncommitted changes`);
+            skippedDirty.push(branchDir);
             continue;
           }
+          const branchRef = (await branchGit.revparse(["--abbrev-ref", "HEAD"])).trim();
+          const canPublish = branchRef.length > 0 && branchRef !== "HEAD";
+          if (canPublish && metaFile?.branch.historyRewrittenFrom) {
+            await this.reconcilePendingRewrite({
+              branchPath,
+              branchDir,
+              branchRef,
+              headSha: (await branchGit.revparse(["HEAD"])).trim(),
+              marker: metaFile.branch.historyRewrittenFrom
+            });
+          }
+          await branchGit.fetch("origin", this.baseBranch);
+          const fetchedBaseTip = (await branchGit.revparse(["FETCH_HEAD"])).trim();
+          const behindCount = parseInt(
+            (await branchGit.raw(["rev-list", "--count", `HEAD..${fetchedBaseTip}`])).trim(),
+            10
+          );
+          const meta = getBranchMetadataFileManager(branchPath, this.contentBranchesPath);
+          if (behindCount === 0) {
+            const currentMeta = await BranchMetadataFileManager.loadOnly(branchPath);
+            const conflictStatus = currentMeta?.branch.conflictStatus;
+            const conflictFiles = currentMeta?.branch.conflictFiles;
+            const conflictAlreadyClean = (conflictStatus === void 0 || conflictStatus === "clean") && (conflictFiles === void 0 || conflictFiles.length === 0);
+            const alreadyClean = conflictAlreadyClean && currentMeta?.branch.rebaseFailure === void 0;
+            if (alreadyClean) {
+              continue;
+            }
+            await meta.save({
+              branch: {
+                name: branchDir,
+                conflictStatus: "clean",
+                conflictFiles: [],
+                rebaseFailure: void 0
+              }
+            });
+            continue;
+          }
+          workerLog(`Rebasing ${branchDir} (${behindCount} commits behind)...`);
+          const preRebaseHead = (await branchGit.revparse(["HEAD"])).trim();
+          const publishedSha = canPublish ? await this.readPublishedSha(branchRef) : null;
+          const conflictedFiles = [];
+          let nextAction = "start";
+          let completed = false;
+          let failureReason;
+          const MAX_ROUNDS = 50;
+          for (let round = 0; round < MAX_ROUNDS && !completed; round++) {
+            try {
+              if (nextAction === "start") {
+                await branchGit.rebase([fetchedBaseTip]);
+              } else if (nextAction === "continue") {
+                await branchGit.rebase(["--continue"]);
+              } else {
+                await branchGit.rebase(["--skip"]);
+              }
+              completed = true;
+            } catch (rebaseErr) {
+              nextAction = "continue";
+              const st = await branchGit.status();
+              if (st.conflicted.length > 0) {
+                await this.afterConflictDetectedForTesting();
+                for (const file of st.conflicted) {
+                  await branchGit.raw(["checkout", "--theirs", file]);
+                  await branchGit.add(file);
+                  conflictedFiles.push(file);
+                }
+              } else {
+                const msg = rebaseErr instanceof Error ? rebaseErr.message : "";
+                if (msg.toLowerCase().includes("nothing to commit") || msg.toLowerCase().includes("apply --skip")) {
+                  nextAction = "skip";
+                } else {
+                  workerLogWarn(
+                    `  Unexpected rebase error in ${branchDir}: ${msg || "Unknown error"}`
+                  );
+                  failureReason = msg || "Unknown error";
+                  await branchGit.rebase(["--abort"]).catch(() => {
+                  });
+                  break;
+                }
+              }
+            }
+          }
+          if (!completed) {
+            workerLogWarn(
+              failureReason !== void 0 ? `  Rebase of ${branchDir} aborted due to unexpected error: ${failureReason}` : `  Rebase of ${branchDir} did not complete within ${MAX_ROUNDS} rounds, aborting`
+            );
+            await branchGit.rebase(["--abort"]).catch(() => {
+            });
+            const rebaseFailureMessage = failureReason ?? `did not complete within ${MAX_ROUNDS} rounds`;
+            const redactedRebaseFailureMessage = redactCredentials(rebaseFailureMessage);
+            failed.push({
+              branch: branchDir,
+              error: redactedRebaseFailureMessage
+            });
+            await this.recordRebaseFailure(branchPath, branchDir, redactedRebaseFailureMessage);
+            continue;
+          }
+          await invalidateBranchContentCaches(branchPath);
+          const normalizedContentRoot = normalizeFilesystemPath(this.contentRoot);
+          const conflictIds = [...new Set(conflictedFiles)].map((f5) => {
+            const fileId = extractIdFromFilename(path12.basename(f5));
+            if (fileId) return fileId;
+            const parentDir = path12.basename(path12.dirname(f5));
+            const dirId = extractIdFromFilename(parentDir);
+            if (dirId) return dirId;
+            const parentPath = normalizeFilesystemPath(path12.dirname(f5));
+            if (path12.basename(f5) === ".collection.json" && parentPath === normalizedContentRoot) {
+              return ROOT_COLLECTION_ID;
+            }
+            return null;
+          }).filter((id) => id !== null);
+          const conflictIdsDeduped = [...new Set(conflictIds)];
+          const hadConflicts = conflictIdsDeduped.length > 0;
+          workerLog(
+            hadConflicts ? `  Rebased ${branchDir} (kept branch version for ${conflictIdsDeduped.length} conflicting file(s))` : `  Rebased ${branchDir} successfully`
+          );
           await meta.save({
             branch: {
               name: branchDir,
-              conflictStatus: "clean",
-              conflictFiles: [],
+              conflictStatus: hadConflicts ? "conflicts-detected" : "clean",
+              conflictFiles: conflictIdsDeduped,
+              // PR-W2: the cycle completed successfully -- clear any prior
+              // failure record regardless of conflict outcome.
               rebaseFailure: void 0
             }
           });
-          continue;
-        }
-        workerLog(`Rebasing ${branchDir} (${behindCount} commits behind)...`);
-        const preRebaseHead = (await branchGit.revparse(["HEAD"])).trim();
-        const publishedSha = canPublish ? await this.readPublishedSha(branchRef) : null;
-        const conflictedFiles = [];
-        let nextAction = "start";
-        let completed = false;
-        let failureReason;
-        const MAX_ROUNDS = 50;
-        for (let round = 0; round < MAX_ROUNDS && !completed; round++) {
-          try {
-            if (nextAction === "start") {
-              await branchGit.rebase([fetchedBaseTip]);
-            } else if (nextAction === "continue") {
-              await branchGit.rebase(["--continue"]);
-            } else {
-              await branchGit.rebase(["--skip"]);
-            }
-            completed = true;
-          } catch (rebaseErr) {
-            nextAction = "continue";
-            const st = await branchGit.status();
-            if (st.conflicted.length > 0) {
-              for (const file of st.conflicted) {
-                await branchGit.raw(["checkout", "--theirs", file]);
-                await branchGit.add(file);
-                conflictedFiles.push(file);
+          rebased.push(branchDir);
+          if (publishedSha !== null) {
+            if (publishedSha === preRebaseHead) {
+              await this.markHistoryRewritten(branchPath, branchDir, publishedSha);
+              if (await this.forcePublishToLocalRemote(branchPath, branchRef, publishedSha)) {
+                await this.enqueueGitHubPush(branchRef);
               }
             } else {
-              const msg = rebaseErr instanceof Error ? rebaseErr.message : "";
-              if (msg.toLowerCase().includes("nothing to commit") || msg.toLowerCase().includes("apply --skip")) {
-                nextAction = "skip";
-              } else {
-                workerLogWarn(
-                  `  Unexpected rebase error in ${branchDir}: ${msg || "Unknown error"}`
-                );
-                failureReason = msg || "Unknown error";
-                await branchGit.rebase(["--abort"]).catch(() => {
-                });
-                break;
-              }
+              const divergence = `rebased locally, but remote.git holds ${publishedSha} for ${branchRef}, which this clone never had (a direct push to the branch?). Left untouched -- reconcile it before submitting again.`;
+              workerLogWarn(`  ${branchDir}: ${divergence}`);
+              await this.recordRebaseFailure(branchPath, branchDir, divergence);
             }
           }
-        }
-        if (!completed) {
-          workerLogWarn(
-            failureReason !== void 0 ? `  Rebase of ${branchDir} aborted due to unexpected error: ${failureReason}` : `  Rebase of ${branchDir} did not complete within ${MAX_ROUNDS} rounds, aborting`
-          );
-          await branchGit.rebase(["--abort"]).catch(() => {
-          });
-          const rebaseFailureMessage = failureReason ?? `did not complete within ${MAX_ROUNDS} rounds`;
-          const redactedRebaseFailureMessage = redactCredentials(rebaseFailureMessage);
-          failed.push({
-            branch: branchDir,
-            error: redactedRebaseFailureMessage
+        } finally {
+          await releaseContentLock?.().catch((releaseErr) => {
+            workerLogWarn(
+              `  Failed to release content-write lock for ${branchDir}: ${getErrorMessage2(releaseErr)}`
+            );
           });
-          await this.recordRebaseFailure(branchPath, branchDir, redactedRebaseFailureMessage);
-          continue;
-        }
-        await invalidateBranchContentCaches(branchPath);
-        const normalizedContentRoot = normalizeFilesystemPath(this.contentRoot);
-        const conflictIds = [...new Set(conflictedFiles)].map((f5) => {
-          const fileId = extractIdFromFilename(path10.basename(f5));
-          if (fileId) return fileId;
-          const parentDir = path10.basename(path10.dirname(f5));
-          const dirId = extractIdFromFilename(parentDir);
-          if (dirId) return dirId;
-          const parentPath = normalizeFilesystemPath(path10.dirname(f5));
-          if (path10.basename(f5) === ".collection.json" && parentPath === normalizedContentRoot) {
-            return ROOT_COLLECTION_ID;
-          }
-          return null;
-        }).filter((id) => id !== null);
-        const conflictIdsDeduped = [...new Set(conflictIds)];
-        const hadConflicts = conflictIdsDeduped.length > 0;
-        workerLog(
-          hadConflicts ? `  Rebased ${branchDir} (kept branch version for ${conflictIdsDeduped.length} conflicting file(s))` : `  Rebased ${branchDir} successfully`
-        );
-        await meta.save({
-          branch: {
-            name: branchDir,
-            conflictStatus: hadConflicts ? "conflicts-detected" : "clean",
-            conflictFiles: conflictIdsDeduped,
-            // PR-W2: the cycle completed successfully -- clear any prior
-            // failure record regardless of conflict outcome.
-            rebaseFailure: void 0
-          }
-        });
-        rebased.push(branchDir);
-        if (publishedSha !== null) {
-          if (publishedSha === preRebaseHead) {
-            await this.markHistoryRewritten(branchPath, branchDir, publishedSha);
-            if (await this.forcePublishToLocalRemote(branchPath, branchRef, publishedSha)) {
-              await this.enqueueGitHubPush(branchRef);
-            }
-          } else {
-            const divergence = `rebased locally, but remote.git holds ${publishedSha} for ${branchRef}, which this clone never had (a direct push to the branch?). Left untouched -- reconcile it before submitting again.`;
-            workerLogWarn(`  ${branchDir}: ${divergence}`);
-            await this.recordRebaseFailure(branchPath, branchDir, divergence);
-          }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : "Unknown error";
@@ -44360,7 +44427,7 @@ var CmsWorker = class {
         await this.recordRebaseFailure(branchPath, branchDir, redactedMessage);
       }
     }
-    return { rebased, skippedDirty, failed };
+    return { rebased, skippedDirty, skippedLocked, failed };
   }
   async refreshAuthCache() {
     if (!this.running || !this.config.refreshAuthCache) return;
@@ -47555,10 +47622,10 @@ var SessionAPI = class extends AbstractAPI {
    */
   async getToken(sessionId, template, expiresInSeconds) {
     this.requireId(sessionId);
-    const path13 = template ? joinPaths(basePath24, sessionId, "tokens", template) : joinPaths(basePath24, sessionId, "tokens");
+    const path15 = template ? joinPaths(basePath24, sessionId, "tokens", template) : joinPaths(basePath24, sessionId, "tokens");
     const requestOptions = {
       method: "POST",
-      path: path13
+      path: path15
     };
     if (expiresInSeconds !== void 0) {
       requestOptions.bodyParams = { expires_in_seconds: expiresInSeconds };
@@ -49680,12 +49747,12 @@ function buildRequest(options) {
       userAgent = USER_AGENT,
       skipApiVersionInUrl = false
     } = options;
-    const { path: path13, method, queryParams, headerParams, bodyParams, formData, options: opts } = requestOptions;
+    const { path: path15, method, queryParams, headerParams, bodyParams, formData, options: opts } = requestOptions;
     const { deepSnakecaseBodyParamKeys = false } = opts || {};
     if (requireSecretKey) {
       assertValidSecretKey(secretKey);
     }
-    const url = skipApiVersionInUrl ? joinPaths(apiUrl, path13) : joinPaths(apiUrl, apiVersion, path13);
+    const url = skipApiVersionInUrl ? joinPaths(apiUrl, path15) : joinPaths(apiUrl, apiVersion, path15);
     const finalUrl = new URL(url);
     if (queryParams) {
       const snakecasedQueryParams = snakecase_keys_default({ ...queryParams });
@@ -51747,38 +51814,38 @@ function createClerkClient(options) {
 }
 
 // ../canopycms/src/auth/file-based-auth-cache.ts
-import fs8 from "node:fs/promises";
-import path11 from "node:path";
+import fs9 from "node:fs/promises";
+import path13 from "node:path";
 var log5 = createDebugLogger({ prefix: "FileBasedAuthCache" });
 async function writeAuthCacheSnapshot(cachePath, files) {
-  await fs8.mkdir(cachePath, { recursive: true });
+  await fs9.mkdir(cachePath, { recursive: true });
   const timestamp2 = Date.now();
-  const snapshotDir = path11.join(cachePath, `snapshot-${timestamp2}`);
-  await fs8.mkdir(snapshotDir, { recursive: true });
+  const snapshotDir = path13.join(cachePath, `snapshot-${timestamp2}`);
+  await fs9.mkdir(snapshotDir, { recursive: true });
   for (const [fileName, data2] of Object.entries(files)) {
-    const tmpPath = path11.join(snapshotDir, `${fileName}.tmp`);
-    const finalPath = path11.join(snapshotDir, fileName);
-    await fs8.writeFile(tmpPath, JSON.stringify(data2, null, 2), "utf-8");
-    await fs8.rename(tmpPath, finalPath);
-  }
-  const currentLink = path11.join(cachePath, "current");
-  const tmpLink = path11.join(cachePath, `current-${timestamp2}`);
-  await fs8.symlink(snapshotDir, tmpLink);
-  await fs8.rename(tmpLink, currentLink);
+    const tmpPath = path13.join(snapshotDir, `${fileName}.tmp`);
+    const finalPath = path13.join(snapshotDir, fileName);
+    await fs9.writeFile(tmpPath, JSON.stringify(data2, null, 2), "utf-8");
+    await fs9.rename(tmpPath, finalPath);
+  }
+  const currentLink = path13.join(cachePath, "current");
+  const tmpLink = path13.join(cachePath, `current-${timestamp2}`);
+  await fs9.symlink(snapshotDir, tmpLink);
+  await fs9.rename(tmpLink, currentLink);
   await cleanupOldSnapshots(cachePath, 2);
   return snapshotDir;
 }
 async function cleanupOldSnapshots(cachePath, keepCount) {
   let entries;
   try {
-    entries = await fs8.readdir(cachePath);
+    entries = await fs9.readdir(cachePath);
   } catch {
     return;
   }
   const snapshots = entries.filter((e5) => e5.startsWith("snapshot-")).sort().reverse();
   for (const snapshot of snapshots.slice(keepCount)) {
     try {
-      await fs8.rm(path11.join(cachePath, snapshot), {
+      await fs9.rm(path13.join(cachePath, snapshot), {
         recursive: true,
         force: true
       });
@@ -51872,7 +51939,7 @@ async function refreshClerkCache(options) {
 }
 
 // worker/index.ts
-import path12 from "node:path";
+import path14 from "node:path";
 async function getSecret(secretArn, retries = 3) {
   const { SecretsManagerClient, GetSecretValueCommand } = await Promise.resolve().then(() => __toESM(require_dist_cjs53(), 1));
   const client = new SecretsManagerClient({});
@@ -51911,7 +51978,7 @@ async function main() {
   if (!clerkSecretKey && process.env.CLERK_SECRET_KEY_SECRET_ARN) {
     clerkSecretKey = await getSecret(process.env.CLERK_SECRET_KEY_SECRET_ARN);
   }
-  const cachePath = path12.join(workspacePath, ".cache");
+  const cachePath = path14.join(workspacePath, ".cache");
   const refreshAuthCache = clerkSecretKey ? async () => {
     const result = await refreshClerkCache({
       secretKey: clerkSecretKey,