@bobbykim/manguito-cms-cli 0.4.6 → 0.5.0

package/dist/index.js

@@ -119,17 +119,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path4) {
-      const ctrl = callVisitor(key, node, visitor, path4);
+    function visit_(key, node, visitor, path7) {
+      const ctrl = callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path4, ctrl);
-        return visit_(key, ctrl, visitor, path4);
+        replaceNode(key, path7, ctrl);
+        return visit_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path4 = Object.freeze(path4.concat(node));
+          path7 = Object.freeze(path7.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path4);
+            const ci = visit_(i, node.items[i], visitor, path7);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -140,13 +140,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path4 = Object.freeze(path4.concat(node));
-          const ck = visit_("key", node.key, visitor, path4);
+          path7 = Object.freeze(path7.concat(node));
+          const ck = visit_("key", node.key, visitor, path7);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path4);
+          const cv = visit_("value", node.value, visitor, path7);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -167,17 +167,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path4) {
-      const ctrl = await callVisitor(key, node, visitor, path4);
+    async function visitAsync_(key, node, visitor, path7) {
+      const ctrl = await callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path4, ctrl);
-        return visitAsync_(key, ctrl, visitor, path4);
+        replaceNode(key, path7, ctrl);
+        return visitAsync_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path4 = Object.freeze(path4.concat(node));
+          path7 = Object.freeze(path7.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path4);
+            const ci = await visitAsync_(i, node.items[i], visitor, path7);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -188,13 +188,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path4 = Object.freeze(path4.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path4);
+          path7 = Object.freeze(path7.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path7);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path4);
+          const cv = await visitAsync_("value", node.value, visitor, path7);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -221,23 +221,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path4) {
+    function callVisitor(key, node, visitor, path7) {
       if (typeof visitor === "function")
-        return visitor(key, node, path4);
+        return visitor(key, node, path7);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path4);
+        return visitor.Map?.(key, node, path7);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path4);
+        return visitor.Seq?.(key, node, path7);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path4);
+        return visitor.Pair?.(key, node, path7);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path4);
+        return visitor.Scalar?.(key, node, path7);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path4);
+        return visitor.Alias?.(key, node, path7);
       return void 0;
     }
-    function replaceNode(key, path4, node) {
-      const parent = path4[path4.length - 1];
+    function replaceNode(key, path7, node) {
+      const parent = path7[path7.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -856,10 +856,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node3 = require_Node();
-    function collectionFromPath(schema, path4, value) {
+    function collectionFromPath(schema, path7, value) {
       let v2 = value;
-      for (let i = path4.length - 1; i >= 0; --i) {
-        const k = path4[i];
+      for (let i = path7.length - 1; i >= 0; --i) {
+        const k = path7[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a2 = [];
           a2[k] = v2;
@@ -878,7 +878,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path4) => path4 == null || typeof path4 === "object" && !!path4[Symbol.iterator]().next().done;
+    var isEmptyPath = (path7) => path7 == null || typeof path7 === "object" && !!path7[Symbol.iterator]().next().done;
     var Collection = class extends Node3.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -908,11 +908,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path4, value) {
-        if (isEmptyPath(path4))
+      addIn(path7, value) {
+        if (isEmptyPath(path7))
           this.add(value);
         else {
-          const [key, ...rest] = path4;
+          const [key, ...rest] = path7;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -926,8 +926,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path4) {
-        const [key, ...rest] = path4;
+      deleteIn(path7) {
+        const [key, ...rest] = path7;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -941,8 +941,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path4, keepScalar) {
-        const [key, ...rest] = path4;
+      getIn(path7, keepScalar) {
+        const [key, ...rest] = path7;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -960,8 +960,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path4) {
-        const [key, ...rest] = path4;
+      hasIn(path7) {
+        const [key, ...rest] = path7;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -971,8 +971,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path4, value) {
-        const [key, ...rest] = path4;
+      setIn(path7, value) {
+        const [key, ...rest] = path7;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3522,9 +3522,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path4, value) {
+      addIn(path7, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path4, value);
+          this.contents.addIn(path7, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3599,14 +3599,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path4) {
-        if (Collection.isEmptyPath(path4)) {
+      deleteIn(path7) {
+        if (Collection.isEmptyPath(path7)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path4) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path7) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3621,10 +3621,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path4, keepScalar) {
-        if (Collection.isEmptyPath(path4))
+      getIn(path7, keepScalar) {
+        if (Collection.isEmptyPath(path7))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path4, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path7, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3635,10 +3635,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path4) {
-        if (Collection.isEmptyPath(path4))
+      hasIn(path7) {
+        if (Collection.isEmptyPath(path7))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path4) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path7) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3655,13 +3655,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path4, value) {
-        if (Collection.isEmptyPath(path4)) {
+      setIn(path7, value) {
+        if (Collection.isEmptyPath(path7)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path4), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path4, value);
+          this.contents.setIn(path7, value);
         }
       }
       /**
@@ -5641,9 +5641,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path4) => {
+    visit.itemAtPath = (cst, path7) => {
       let item = cst;
-      for (const [field, index] of path4) {
+      for (const [field, index] of path7) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5652,23 +5652,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path4) => {
-      const parent = visit.itemAtPath(cst, path4.slice(0, -1));
-      const field = path4[path4.length - 1][0];
+    visit.parentCollection = (cst, path7) => {
+      const parent = visit.itemAtPath(cst, path7.slice(0, -1));
+      const field = path7[path7.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path4, item, visitor) {
-      let ctrl = visitor(item, path4);
+    function _visit(path7, item, visitor) {
+      let ctrl = visitor(item, path7);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path4.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path7.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5679,10 +5679,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path4);
+            ctrl = ctrl(item, path7);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path4) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path7) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6988,14 +6988,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs4 = this.flowScalar(this.type);
+              const fs7 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map2.items.push({ start, key: fs4, sep: [] });
+                map2.items.push({ start, key: fs7, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs4);
+                this.stack.push(fs7);
               } else {
-                Object.assign(it2, { key: fs4, sep: [] });
+                Object.assign(it2, { key: fs7, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7123,13 +7123,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs4 = this.flowScalar(this.type);
+              const fs7 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs4, sep: [] });
+                fc.items.push({ start: [], key: fs7, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs4);
+                this.stack.push(fs7);
               else
-                Object.assign(it2, { key: fs4, sep: [] });
+                Object.assign(it2, { key: fs7, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7521,13 +7521,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve10, reject) {
+          return new Promise(function(resolve12, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve10(res);
+              resolve12(res);
             });
           });
       };
@@ -7556,13 +7556,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve10, reject) {
+          return new Promise(function(resolve12, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve10(res);
+              resolve12(res);
             });
           });
       };
@@ -7607,13 +7607,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve10, reject) {
+          return new Promise(function(resolve12, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve10(res);
+              resolve12(res);
             });
           });
       };
@@ -10880,15 +10880,15 @@ var require_pg_connection_string = __commonJS({
       if (config3.sslnegotiation === "direct" && config3.ssl === void 0) {
         config3.ssl = true;
       }
-      const fs4 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
+      const fs7 = config3.sslcert || config3.sslkey || config3.sslrootcert ? __require("fs") : null;
       if (config3.sslcert) {
-        config3.ssl.cert = fs4.readFileSync(config3.sslcert).toString();
+        config3.ssl.cert = fs7.readFileSync(config3.sslcert).toString();
       }
       if (config3.sslkey) {
-        config3.ssl.key = fs4.readFileSync(config3.sslkey).toString();
+        config3.ssl.key = fs7.readFileSync(config3.sslkey).toString();
       }
       if (config3.sslrootcert) {
-        config3.ssl.ca = fs4.readFileSync(config3.sslrootcert).toString();
+        config3.ssl.ca = fs7.readFileSync(config3.sslrootcert).toString();
       }
       if (options.useLibpqCompat && config3.uselibpqcompat) {
         throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -12334,7 +12334,7 @@ var require_dist2 = __commonJS({
     function parse4(stream, callback) {
       const parser = new parser_1.Parser();
       stream.on("data", (buffer) => parser.parse(buffer, callback));
-      return new Promise((resolve10) => stream.on("end", () => resolve10()));
+      return new Promise((resolve12) => stream.on("end", () => resolve12()));
     }
   }
 });
@@ -12722,7 +12722,7 @@ var require_helper = __commonJS({
   "../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/helper.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path4 = __require("path");
+    var path7 = __require("path");
     var Stream = __require("stream").Stream;
     var split = require_split2();
     var util = __require("util");
@@ -12761,7 +12761,7 @@ var require_helper = __commonJS({
     };
     module.exports.getFileName = function(rawEnv) {
       var env = rawEnv || process.env;
-      var file2 = env.PGPASSFILE || (isWin ? path4.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path4.join(env.HOME || "./", ".pgpass"));
+      var file2 = env.PGPASSFILE || (isWin ? path7.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path7.join(env.HOME || "./", ".pgpass"));
       return file2;
     };
     module.exports.usePgPass = function(stats, fname) {
@@ -12894,16 +12894,16 @@ var require_lib = __commonJS({
   "../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path4 = __require("path");
-    var fs4 = __require("fs");
+    var path7 = __require("path");
+    var fs7 = __require("fs");
     var helper = require_helper();
     module.exports = function(connInfo, cb) {
       var file2 = helper.getFileName();
-      fs4.stat(file2, function(err, stat) {
+      fs7.stat(file2, function(err, stat) {
         if (err || !helper.usePgPass(stat, file2)) {
           return cb(void 0);
         }
-        var st = fs4.createReadStream(file2);
+        var st = fs7.createReadStream(file2);
         helper.getPassword(connInfo, st, cb);
       });
     };
@@ -13103,12 +13103,12 @@ var require_client = __commonJS({
           this._connect(callback);
           return;
         }
-        return new this._Promise((resolve10, reject) => {
+        return new this._Promise((resolve12, reject) => {
           this._connect((error51) => {
             if (error51) {
               reject(error51);
             } else {
-              resolve10(this);
+              resolve12(this);
             }
           });
         });
@@ -13455,8 +13455,8 @@ var require_client = __commonJS({
         } else {
           query = new Query2(config3, values, callback);
           if (!query.callback) {
-            result = new this._Promise((resolve10, reject) => {
-              query.callback = (err, res) => err ? reject(err) : resolve10(res);
+            result = new this._Promise((resolve12, reject) => {
+              query.callback = (err, res) => err ? reject(err) : resolve12(res);
             }).catch((err) => {
               Error.captureStackTrace(err);
               throw err;
@@ -13540,8 +13540,8 @@ var require_client = __commonJS({
         if (cb) {
           this.connection.once("end", cb);
         } else {
-          return new this._Promise((resolve10) => {
-            this.connection.once("end", resolve10);
+          return new this._Promise((resolve12) => {
+            this.connection.once("end", resolve12);
           });
         }
       }
@@ -13591,8 +13591,8 @@ var require_pg_pool = __commonJS({
       const cb = function(err, client) {
         err ? rej(err) : res(client);
       };
-      const result = new Promise2(function(resolve10, reject) {
-        res = resolve10;
+      const result = new Promise2(function(resolve12, reject) {
+        res = resolve12;
         rej = reject;
       }).catch((err) => {
         Error.captureStackTrace(err);
@@ -13653,7 +13653,7 @@ var require_pg_pool = __commonJS({
         if (typeof Promise2.try === "function") {
           return Promise2.try(f);
         }
-        return new Promise2((resolve10) => resolve10(f()));
+        return new Promise2((resolve12) => resolve12(f()));
       }
       _isFull() {
         return this._clients.length >= this.options.max;
@@ -14047,8 +14047,8 @@ var require_query2 = __commonJS({
     NativeQuery.prototype._getPromise = function() {
       if (this._promise) return this._promise;
       this._promise = new Promise(
-        function(resolve10, reject) {
-          this._once("end", resolve10);
+        function(resolve12, reject) {
+          this._once("end", resolve12);
           this._once("error", reject);
         }.bind(this)
       );
@@ -14227,12 +14227,12 @@ var require_client2 = __commonJS({
         this._connect(callback);
         return;
       }
-      return new this._Promise((resolve10, reject) => {
+      return new this._Promise((resolve12, reject) => {
         this._connect((error51) => {
           if (error51) {
             reject(error51);
           } else {
-            resolve10(this);
+            resolve12(this);
           }
         });
       });
@@ -14256,8 +14256,8 @@ var require_client2 = __commonJS({
         query = new NativeQuery(config3, values, callback);
         if (!query.callback) {
           let resolveOut, rejectOut;
-          result = new this._Promise((resolve10, reject) => {
-            resolveOut = resolve10;
+          result = new this._Promise((resolve12, reject) => {
+            resolveOut = resolve12;
             rejectOut = reject;
           }).catch((err) => {
             Error.captureStackTrace(err);
@@ -14320,8 +14320,8 @@ var require_client2 = __commonJS({
       }
       let result;
       if (!cb) {
-        result = new this._Promise(function(resolve10, reject) {
-          cb = (err) => err ? reject(err) : resolve10();
+        result = new this._Promise(function(resolve12, reject) {
+          cb = (err) => err ? reject(err) : resolve12();
         });
       }
       this.native.end(function() {
@@ -14468,8 +14468,8 @@ import { Command } from "commander";
 
 // src/commands/build.ts
 init_esm_shims();
-import { mkdirSync, statSync as statSync2, existsSync as existsSync3, readdirSync as readdirSync2, writeFileSync } from "fs";
-import { resolve as resolve3, join as join7, dirname } from "path";
+import { mkdirSync, statSync as statSync2, existsSync as existsSync3, readdirSync as readdirSync3, writeFileSync } from "fs";
+import { resolve as resolve3, join as join8, dirname } from "path";
 import { createRequire } from "module";
 import { build as viteBuild } from "vite";
 import { build as tsupBuild } from "tsup";
@@ -15256,10 +15256,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15668,11 +15668,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -15819,16 +15819,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path4 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -15855,17 +15855,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path4 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -15897,8 +15897,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -28671,13 +28671,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29093,6 +29093,8 @@ import * as path2 from "path";
 import * as fs from "fs";
 import * as path from "path";
 var import_bcryptjs = __toESM(require_bcryptjs(), 1);
+import * as fs3 from "fs";
+import * as path3 from "path";
 var snakeCaseName = external_exports.string().regex(/^[a-z][a-z0-9_]*$/, 'Must be snake_case (e.g. "blog_post")');
 var maxSizeString = external_exports.string().regex(
   /^\d+(\.\d+)?\s*(B|KB|MB|GB)$/i,
@@ -29839,8 +29841,8 @@ function getNameSegment(machineName) {
   const idx = machineName.indexOf("--");
   return idx === -1 ? machineName : machineName.slice(idx + 2);
 }
-function zodPathToString(path4) {
-  return path4.reduce((acc, seg) => {
+function zodPathToString(path42) {
+  return path42.reduce((acc, seg) => {
     const s = typeof seg === "symbol" ? String(seg) : seg;
     return typeof s === "number" ? `${acc}[${s}]` : acc ? `${acc}.${s}` : s;
   }, "");
@@ -30261,6 +30263,342 @@ async function hashPassword(password2) {
 async function verifyPassword(password2, stored) {
   return import_bcryptjs.default.compare(password2, stored);
 }
+var STRUCTURAL_KINDS = ["content_types", "taxonomy_types"];
+function typeEntries(registry2, kinds = STRUCTURAL_KINDS) {
+  const out = [];
+  for (const kind of kinds) {
+    for (const [name, type] of Object.entries(registry2[kind])) {
+      out.push([name, type.fields]);
+    }
+  }
+  return out;
+}
+function fieldsByColumn(registry2, kinds = STRUCTURAL_KINDS) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [typeName, fields] of typeEntries(registry2, kinds)) {
+    const byColumn2 = /* @__PURE__ */ new Map();
+    for (const f of fields) {
+      if (!isColumnBacked2(f)) continue;
+      byColumn2.set(f.db_column.column_name, f);
+    }
+    out.set(typeName, byColumn2);
+  }
+  return out;
+}
+function checkUnionCompleteness(input2) {
+  const { union: union3, projections, currentVersion, snapshots } = input2;
+  const errors = [];
+  const unionColumns = fieldsByColumn(union3);
+  for (const [version3, projection] of Object.entries(projections)) {
+    if (version3 === currentVersion) continue;
+    for (const [typeName, type] of Object.entries(projection.types)) {
+      const columns = unionColumns.get(typeName);
+      if (columns === void 0) {
+        errors.push({
+          file: `schemas/versions/${version3}`,
+          code: "VERSION_COLUMN_MISSING",
+          message: `Live version ${version3} exposes type "${typeName}", which the current schema no longer defines. Every column a live version serves must still exist. Keep "${typeName}" in the current schema with its fields marked "removed": true, or retire it with \`manguito version:retire ${version3}\` \u2014 which will refuse if ${version3} is the newest cut version.`
+        });
+        continue;
+      }
+      for (const f of type.fields) {
+        if (columns.has(f.column_name)) continue;
+        errors.push({
+          file: `schemas/versions/${version3}`,
+          code: "VERSION_COLUMN_MISSING",
+          message: `Live version ${version3} exposes column "${f.column_name}" on "${typeName}" (as "${f.exposed_as}"), which the current schema neither exposes nor retains. Either add "column": "${f.column_name}" to the field that replaced it, or add a field { "name": "${f.exposed_as}", "column": "${f.column_name}", "removed": true } to retain the column while ${version3} is live \u2014 use a different "name" if "${f.exposed_as}" is still a live field.`
+        });
+      }
+    }
+  }
+  const paragraphColumns = fieldsByColumn(union3, ["paragraph_types"]);
+  for (const snap of snapshots) {
+    for (const [typeName, fields] of typeEntries(snap.registry, ["paragraph_types"])) {
+      const columns = paragraphColumns.get(typeName);
+      if (columns === void 0) {
+        errors.push({
+          file: `schemas/versions/${snap.version}`,
+          code: "VERSION_COLUMN_MISSING",
+          message: `Live version ${snap.version} exposes paragraph type "${typeName}", which the current schema no longer defines. Every column a live version serves must still exist. Keep "${typeName}" in the current schema with its fields marked "removed": true, or retire it with \`manguito version:retire ${snap.version}\` \u2014 which will refuse if ${snap.version} is the newest cut version.`
+        });
+        continue;
+      }
+      for (const f of fields) {
+        if (!isColumnBacked2(f) || f.removed === true) continue;
+        const column = f.db_column.column_name;
+        if (columns.has(column)) continue;
+        errors.push({
+          file: `schemas/versions/${snap.version}`,
+          code: "VERSION_COLUMN_MISSING",
+          message: `Live version ${snap.version} exposes column "${column}" on paragraph type "${typeName}" (as "${f.name}"), which the current schema neither exposes nor retains. Either add "column": "${column}" to the field that replaced it, or add a field { "name": "${f.name}", "column": "${column}", "removed": true } to retain the column while ${snap.version} is live \u2014 use a different "name" if "${f.name}" is still a live field.`
+        });
+      }
+    }
+  }
+  return errors;
+}
+function checkOrphanedTombstones(input2) {
+  const { current, projections, currentVersion, snapshots } = input2;
+  const errors = [];
+  const exposed = /* @__PURE__ */ new Set();
+  for (const [version3, projection] of Object.entries(projections)) {
+    if (version3 === currentVersion) continue;
+    for (const [typeName, type] of Object.entries(projection.types)) {
+      for (const f of type.fields) exposed.add(`${typeName}.${f.column_name}`);
+    }
+  }
+  for (const [typeName, fields] of typeEntries(current)) {
+    for (const f of fields) {
+      if (f.removed !== true || !isColumnBacked2(f)) continue;
+      if (exposed.has(`${typeName}.${f.db_column.column_name}`)) continue;
+      errors.push({
+        file: current.schemas[typeName]?.source_file ?? "",
+        code: "ORPHANED_TOMBSTONE",
+        message: `Field "${f.name}" on "${typeName}" is marked "removed": true, retaining column "${f.db_column.column_name}", but no live version exposes that column any more. It is a column nothing can read. Delete the field \u2014 that shrinks the union and lets db codegen drop the column.`
+      });
+    }
+  }
+  const paragraphExposed = /* @__PURE__ */ new Set();
+  for (const snap of snapshots) {
+    for (const [typeName, fields] of typeEntries(snap.registry, ["paragraph_types"])) {
+      for (const f of fields) {
+        if (!isColumnBacked2(f) || f.removed === true) continue;
+        paragraphExposed.add(`${typeName}.${f.db_column.column_name}`);
+      }
+    }
+  }
+  for (const [typeName, fields] of typeEntries(current, ["paragraph_types"])) {
+    for (const f of fields) {
+      if (f.removed !== true || !isColumnBacked2(f)) continue;
+      if (paragraphExposed.has(`${typeName}.${f.db_column.column_name}`)) continue;
+      errors.push({
+        file: current.schemas[typeName]?.source_file ?? "",
+        code: "ORPHANED_TOMBSTONE",
+        message: `Field "${f.name}" on paragraph type "${typeName}" is marked "removed": true, retaining column "${f.db_column.column_name}", but no live version exposes that column any more. It is a column nothing can read. Delete the field \u2014 that shrinks the union and lets db codegen drop the column.`
+      });
+    }
+  }
+  return errors;
+}
+function checkFieldTypeChangedWhileLive(input2) {
+  const { current, snapshots } = input2;
+  const errors = [];
+  function compare(kinds, typeLabel) {
+    const currentByType = fieldsByColumn(current, kinds);
+    for (const snap of snapshots) {
+      for (const [typeName, snapColumns] of fieldsByColumn(snap.registry, kinds)) {
+        const currentColumns = currentByType.get(typeName);
+        if (!currentColumns) continue;
+        for (const [col, oldField] of snapColumns) {
+          const currentField = currentColumns.get(col);
+          if (!currentField) continue;
+          if (currentField.field_type === oldField.field_type) continue;
+          errors.push({
+            file: `schemas/versions/${snap.version}`,
+            code: "FIELD_TYPE_CHANGED_WHILE_LIVE",
+            message: `Column "${col}" on ${typeLabel}"${typeName}" is exposed by live version ${snap.version} as ${oldField.field_type}, but the current schema now types it ${currentField.field_type}. A live version's contract cannot change type under its consumers \u2014 retire ${snap.version} first, or keep the field's type stable and introduce the change as a new column instead.`
+          });
+        }
+      }
+    }
+  }
+  compare(STRUCTURAL_KINDS, "");
+  compare(["paragraph_types"], "paragraph type ");
+  return errors;
+}
+function validateVersionModel(input2) {
+  return [
+    ...checkUnionCompleteness(input2),
+    ...checkOrphanedTombstones(input2),
+    ...checkFieldTypeChangedWhileLive(input2)
+  ];
+}
+function collectFallbacks(current) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [typeName, type] of [
+    ...Object.entries(current.content_types),
+    ...Object.entries(current.taxonomy_types)
+  ]) {
+    for (const f of type.fields) {
+      if (f.fallback === void 0 || !isColumnBacked2(f)) continue;
+      out.set(`${typeName}.${f.db_column.column_name}`, f.fallback);
+    }
+  }
+  return out;
+}
+function buildProjections(input2) {
+  const { current, currentVersion, snapshots } = input2;
+  const byVersion = [
+    ...snapshots,
+    { version: currentVersion, registry: current }
+  ];
+  const fallbacks = collectFallbacks(current);
+  const out = {};
+  for (const { version: version3, registry: registry2 } of byVersion) {
+    const types3 = {};
+    for (const [typeName, type] of [
+      ...Object.entries(registry2.content_types),
+      ...Object.entries(registry2.taxonomy_types)
+    ]) {
+      const fields = type.fields.filter((f) => isColumnBacked2(f) && f.removed !== true).map((f) => {
+        const column_name = f.db_column.column_name;
+        const fallback = fallbacks.get(`${typeName}.${column_name}`);
+        return fallback === void 0 ? { column_name, exposed_as: f.name } : { column_name, exposed_as: f.name, fallback };
+      });
+      types3[typeName] = { fields };
+    }
+    out[version3] = { version: version3, types: types3 };
+  }
+  return out;
+}
+function versionNumber(version3) {
+  const n = Number.parseInt(version3.replace(/^v/, ""), 10);
+  return Number.isNaN(n) ? 0 : n;
+}
+function computeVersionModel(input2) {
+  const { current, snapshots } = input2;
+  const highest = snapshots.reduce((max, s) => Math.max(max, versionNumber(s.version)), 0);
+  const currentVersion = `v${highest + 1}`;
+  const live = [
+    ...new Set(snapshots.map((s) => s.version).sort((a2, b2) => versionNumber(a2) - versionNumber(b2))),
+    currentVersion
+  ];
+  const union3 = current;
+  const projections = buildProjections({ current, currentVersion, snapshots });
+  const errors = validateVersionModel({ current, currentVersion, snapshots, union: union3, projections });
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, value: { current: currentVersion, live, union: union3, projections } };
+}
+function discoverSnapshotDirs(versionsDir) {
+  const entries = fs3.readdirSync(versionsDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && /^v\d+$/.test(e.name)).map((e) => ({ version: e.name, n: Number.parseInt(e.name.slice(1), 10) })).sort((a2, b2) => a2.n - b2.n).map(({ version: version3 }) => ({ version: version3, dir: path3.join(versionsDir, version3) }));
+}
+function walkSnapshotFolders(dir, folders) {
+  const files = [];
+  const errors = [];
+  for (const [folderKey, schemaType] of Object.entries(FOLDER_KEY_TO_SCHEMA_TYPE)) {
+    const folderPath = path3.join(dir, folders[folderKey]);
+    if (!directoryExists(folderPath)) continue;
+    let entries;
+    try {
+      entries = fs3.readdirSync(folderPath);
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (!isSupportedExtension(entry)) continue;
+      const filePath = path3.join(folderPath, entry);
+      const result = loadSchemaFile(filePath);
+      if (!result.ok) {
+        errors.push(...result.errors);
+        continue;
+      }
+      files.push({ path: filePath, raw: result.value, schema_type: schemaType });
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, value: files };
+}
+function wrapAsSnapshotInvalid(version3, errors) {
+  return errors.map((e) => ({
+    file: e.file,
+    code: "VERSION_SNAPSHOT_INVALID",
+    message: `Snapshot ${version3} failed to load: ${e.message}`,
+    ...e.path !== void 0 ? { path: e.path } : {}
+  }));
+}
+function loadSnapshot(version3, dir, folders, current) {
+  const walked = walkSnapshotFolders(dir, folders);
+  if (!walked.ok) return { ok: false, errors: wrapAsSnapshotInvalid(version3, walked.errors) };
+  const schemas = [];
+  const errors = [];
+  for (const file2 of walked.value) {
+    const parsed = parseSchema(file2.raw, file2.schema_type, file2.path);
+    if (!parsed.ok) {
+      errors.push(...parsed.errors);
+      continue;
+    }
+    schemas.push(parsed.schema);
+  }
+  if (errors.length > 0) return { ok: false, errors: wrapAsSnapshotInvalid(version3, errors) };
+  const registry2 = buildSchemaRegistry(schemas, current.routes, current.roles);
+  return { ok: true, value: { version: version3, registry: registry2 } };
+}
+function loadVersionSnapshots(config3, current) {
+  const versionsDir = path3.join(config3.base_path, "versions");
+  if (!directoryExists(versionsDir)) return { ok: true, value: [] };
+  const snapshots = [];
+  const errors = [];
+  for (const { version: version3, dir } of discoverSnapshotDirs(versionsDir)) {
+    const result = loadSnapshot(version3, dir, config3.folders, current);
+    if (!result.ok) {
+      errors.push(...result.errors);
+      continue;
+    }
+    snapshots.push(result.value);
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, value: snapshots };
+}
+function typeEntries2(registry2) {
+  return [
+    ...Object.entries(registry2.content_types),
+    ...Object.entries(registry2.taxonomy_types),
+    ...Object.entries(registry2.paragraph_types)
+  ].map(([name, type]) => [name, type.fields]);
+}
+function byColumn(fields) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    if (!isColumnBacked2(f)) continue;
+    out.set(f.db_column.column_name, f);
+  }
+  return out;
+}
+function describeSchemaChange(input2) {
+  const { from, to } = input2;
+  const fromTypes = new Map(from === null ? [] : typeEntries2(from.registry));
+  const types3 = [];
+  for (const [typeName, toFields] of typeEntries2(to.registry)) {
+    const fromFields = fromTypes.get(typeName);
+    const fromByColumn = byColumn(fromFields ?? []);
+    const fields = [];
+    for (const [column, toField] of byColumn(toFields)) {
+      const fromField = fromByColumn.get(column);
+      if (fromField === void 0) {
+        fields.push({ kind: "added", column, name: toField.name, field_type: toField.field_type });
+        continue;
+      }
+      const wasTombstone = fromField.removed === true;
+      const isTombstone = toField.removed === true;
+      if (!wasTombstone && isTombstone) {
+        fields.push({
+          kind: "tombstoned",
+          column,
+          name: toField.name,
+          // Omitted entirely rather than set undefined, so an equality check
+          // against the no-fallback case is clean.
+          ...toField.fallback !== void 0 && { fallback: toField.fallback }
+        });
+        continue;
+      }
+      if (wasTombstone && !isTombstone) {
+        fields.push({ kind: "restored", column, name: toField.name });
+        continue;
+      }
+      if (fromField.name !== toField.name) {
+        fields.push({ kind: "renamed", column, from_name: fromField.name, to_name: toField.name });
+      }
+    }
+    types3.push({
+      type: typeName,
+      status: fromFields === void 0 ? "added" : "present",
+      fields
+    });
+  }
+  const identical = types3.every((t) => t.status === "present" && t.fields.length === 0);
+  return { from: from?.version ?? null, to: to.version, types: types3, identical };
+}
 
 // ../db/dist/index.mjs
 init_esm_shims();
@@ -30467,7 +30805,7 @@ init_esm_shims();
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path4, field }, columnIndex) => {
+    (result2, { path: path7, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -30479,8 +30817,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path4.entries()) {
-        if (pathChunkIndex < path4.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path7.entries()) {
+        if (pathChunkIndex < path7.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -30488,8 +30826,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path4.length === 2) {
-            const objectName = path4[0];
+          if (joinsNotNullableMap && is(field, Column) && path7.length === 2) {
+            const objectName = path7[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -33857,7 +34195,7 @@ var PgSelectQueryBuilderBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join13) => join13.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join14) => join14.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -35081,7 +35419,7 @@ var PgUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join13) => join13.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join14) => join14.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -35177,10 +35515,10 @@ var PgUpdateBase = class extends QueryPromise {
           const fromFields = this.getTableLikeFields(this.config.from);
           fields[tableName] = fromFields;
         }
-        for (const join13 of this.config.joins) {
-          const tableName2 = getTableLikeName(join13.table);
-          if (typeof tableName2 === "string" && !is(join13.table, SQL)) {
-            const fromFields = this.getTableLikeFields(join13.table);
+        for (const join14 of this.config.joins) {
+          const tableName2 = getTableLikeName(join14.table);
+          if (typeof tableName2 === "string" && !is(join14.table, SQL)) {
+            const fromFields = this.getTableLikeFields(join14.table);
             fields[tableName2] = fromFields;
           }
         }
@@ -38944,7 +39282,7 @@ var ds = T((th, ps) => {
     return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(r);
   }
   a(ls, "isBase64");
-  function fs4(r) {
+  function fs7(r) {
     if (typeof r != "string") throw new TypeError("SASL: attribute pairs text must be a string");
     return new Map(r.split(",").map((e) => {
       if (!/^.=/.test(e)) throw new Error("SASL: Invalid attribute pair entry");
@@ -38952,9 +39290,9 @@ var ds = T((th, ps) => {
       return [t, n];
     }));
   }
-  a(fs4, "parseAttributePairs");
+  a(fs7, "parseAttributePairs");
   function qu(r) {
-    let e = fs4(r), t = e.get("r");
+    let e = fs7(r), t = e.get("r");
     if (t) {
       if (!Ou(t)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
     } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
@@ -38971,7 +39309,7 @@ var ds = T((th, ps) => {
   }
   a(qu, "parseServerFirstMessage");
   function Qu(r) {
-    let t = fs4(r).get("v");
+    let t = fs7(r).get("v");
     if (t) {
       if (!ls(t)) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
     } else throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing");
@@ -41707,8 +42045,8 @@ function drizzle2(...params) {
 // ../db/dist/index.mjs
 import { execSync, spawnSync } from "child_process";
 import crypto2 from "crypto";
-import path3 from "path";
-import fs3 from "fs/promises";
+import path4 from "path";
+import fs4 from "fs/promises";
 import { readFileSync as readFileSync2 } from "fs";
 import path22 from "path";
 function createPostgresAdapter(options = {}) {
@@ -42194,32 +42532,32 @@ async function seedSystemTables(db, registry2, options = {}) {
 }
 function resolvedPathEnv() {
   const root = process.cwd();
-  const localBin = path3.join(root, "node_modules", ".bin");
-  const existing = (process.env.PATH ?? "").split(path3.delimiter).filter(Boolean).map((entry) => path3.isAbsolute(entry) ? entry : path3.resolve(root, entry));
-  return { ...process.env, PATH: [localBin, ...existing].join(path3.delimiter) };
+  const localBin = path4.join(root, "node_modules", ".bin");
+  const existing = (process.env.PATH ?? "").split(path4.delimiter).filter(Boolean).map((entry) => path4.isAbsolute(entry) ? entry : path4.resolve(root, entry));
+  return { ...process.env, PATH: [localBin, ...existing].join(path4.delimiter) };
 }
 async function runDevMigration(configPath) {
   execSync(`drizzle-kit push --config=${configPath}`, {
     stdio: "inherit",
-    cwd: path3.dirname(configPath),
+    cwd: path4.dirname(configPath),
     env: resolvedPathEnv()
   });
 }
 async function generateMigration(configPath, migrationsFolder) {
   let beforeFiles = [];
   try {
-    const entries = await fs3.readdir(migrationsFolder);
+    const entries = await fs4.readdir(migrationsFolder);
     beforeFiles = entries.filter((f) => f.endsWith(".sql"));
   } catch {
   }
   execSync(`drizzle-kit generate --config=${configPath}`, {
     stdio: "inherit",
-    cwd: path3.dirname(configPath),
+    cwd: path4.dirname(configPath),
     env: resolvedPathEnv()
   });
   let afterFiles = [];
   try {
-    const entries = await fs3.readdir(migrationsFolder);
+    const entries = await fs4.readdir(migrationsFolder);
     afterFiles = entries.filter((f) => f.endsWith(".sql"));
   } catch {
   }
@@ -42240,16 +42578,16 @@ async function applyMigrations(configPath, db, options) {
   if (statusBefore.pending.length > 0) {
     let journalEntries = [];
     try {
-      const journalPath = path3.join(migrationsFolder, "meta", "_journal.json");
-      const raw2 = await fs3.readFile(journalPath, "utf-8");
+      const journalPath = path4.join(migrationsFolder, "meta", "_journal.json");
+      const raw2 = await fs4.readFile(journalPath, "utf-8");
       journalEntries = JSON.parse(raw2).entries;
     } catch {
     }
     for (const pendingFile of statusBefore.pending) {
-      const sqlPath = path3.join(migrationsFolder, pendingFile);
+      const sqlPath = path4.join(migrationsFolder, pendingFile);
       let sqlContent;
       try {
-        sqlContent = await fs3.readFile(sqlPath, "utf-8");
+        sqlContent = await fs4.readFile(sqlPath, "utf-8");
       } catch {
         continue;
       }
@@ -42279,7 +42617,7 @@ async function applyMigrations(configPath, db, options) {
     "drizzle-kit",
     ["migrate", `--config=${configPath}`],
     {
-      cwd: path3.dirname(configPath),
+      cwd: path4.dirname(configPath),
       // inherit lets drizzle-kit write its spinner and errors directly to the
       // terminal in real time — capturing stdout/stderr swallows ANSI overwrites
       // and hides the actual error message.
@@ -42305,8 +42643,8 @@ async function getMigrationStatus(db, options) {
   const { migrationsTable, migrationsFolder } = options;
   let journalEntries;
   try {
-    const journalPath = path3.join(migrationsFolder, "meta", "_journal.json");
-    const raw2 = await fs3.readFile(journalPath, "utf-8");
+    const journalPath = path4.join(migrationsFolder, "meta", "_journal.json");
+    const raw2 = await fs4.readFile(journalPath, "utf-8");
     const journal = JSON.parse(raw2);
     journalEntries = journal.entries;
   } catch {
@@ -42404,17 +42742,17 @@ function scanMigrationFiles(filePaths) {
 // src/codegen/registry.ts
 init_esm_shims();
 import { writeFile } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 async function generateSchemaRegistry(registry2, targetDir) {
   const content = `export const schemaRegistry = ${JSON.stringify(registry2, null, 2)} as const
 `;
-  await writeFile(join2(targetDir, "schema-registry.ts"), content, "utf8");
+  await writeFile(join3(targetDir, "schema-registry.ts"), content, "utf8");
 }
 
 // src/codegen/routes.ts
 init_esm_shims();
 import { writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // ../api/dist/codegen/index.mjs
 init_esm_shims();
@@ -43087,13 +43425,13 @@ function generateRoutes(registry2) {
 // src/codegen/routes.ts
 async function generateRoutes2(registry2, targetDir) {
   const content = generateRoutes(registry2);
-  await writeFile2(join3(targetDir, "routes.ts"), content, "utf8");
+  await writeFile2(join4(targetDir, "routes.ts"), content, "utf8");
 }
 
 // src/codegen/forms.ts
 init_esm_shims();
 import { mkdir, writeFile as writeFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // ../admin/dist/codegen/index.js
 init_esm_shims();
@@ -43261,19 +43599,19 @@ async function generateForms(registry2, formsDir) {
   ];
   for (const schema of schemas) {
     const content = generateFormComponent(schema);
-    await writeFile3(join4(formsDir, `${schema.name}.vue`), content, "utf8");
+    await writeFile3(join5(formsDir, `${schema.name}.vue`), content, "utf8");
   }
 }
 
 // src/codegen/server-entries.ts
 init_esm_shims();
 import { writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 async function generateServerEntries(options, targetDir) {
   await Promise.all([
-    writeFile4(join5(targetDir, "server.ts"), serverEntry(options), "utf8"),
-    writeFile4(join5(targetDir, "handler.ts"), lambdaEntry(options), "utf8"),
-    writeFile4(join5(targetDir, "vercel.ts"), vercelEntry(options), "utf8")
+    writeFile4(join6(targetDir, "server.ts"), serverEntry(options), "utf8"),
+    writeFile4(join6(targetDir, "handler.ts"), lambdaEntry(options), "utf8"),
+    writeFile4(join6(targetDir, "vercel.ts"), vercelEntry(options), "utf8")
   ]);
 }
 function appSetup() {
@@ -43457,7 +43795,7 @@ export default handle(app)
 // src/codegen/programmatic-registry.ts
 init_esm_shims();
 import { writeFile as writeFile5 } from "fs/promises";
-import { join as join6, relative } from "path";
+import { join as join7, relative } from "path";
 function importSpecifier(targetDir, file2) {
   let rel = relative(targetDir, file2).replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
@@ -43479,7 +43817,7 @@ export const programmaticResolvers = new Map<string, ProgrammaticFieldDefinition
 ${entries},
 ])
 `;
-  await writeFile5(join6(targetDir, "programmatic-registry.ts"), body, "utf8");
+  await writeFile5(join7(targetDir, "programmatic-registry.ts"), body, "utf8");
 }
 
 // src/utils/config.ts
@@ -43659,10 +43997,10 @@ async function runBuild(options, deps) {
   );
   const generatedDir = resolve3(cwd, "dist/generated");
   mkdirSync(generatedDir, { recursive: true });
-  writeFileSync(join7(generatedDir, "schema.ts"), generateSchemaFile(registry2), "utf8");
+  writeFileSync(join8(generatedDir, "schema.ts"), generateSchemaFile(registry2), "utf8");
   await generateSchemaRegistry(registry2, generatedDir);
   await generateRoutes2(registry2, generatedDir);
-  await generateForms(registry2, join7(generatedDir, "forms"));
+  await generateForms(registry2, join8(generatedDir, "forms"));
   const programmaticDir = resolve3(cwd, config3.programmatic.dir);
   const resolverFiles = existsSync3(programmaticDir) ? walkFiles(programmaticDir).filter((f) => /\.(ts|mjs|js)$/.test(f)) : [];
   await generateProgrammaticRegistry(resolverFiles, generatedDir);
@@ -43729,14 +44067,14 @@ async function needsRebuild(cwd) {
   );
 }
 function resolveAdminRoot(cwd) {
-  const cwdRequire = createRequire(join7(cwd, "package.json"));
+  const cwdRequire = createRequire(join8(cwd, "package.json"));
   const adminPkgJson = cwdRequire.resolve("@bobbykim/manguito-cms-admin/package.json");
   return dirname(adminPkgJson);
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const full = join7(dir, entry.name);
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    const full = join8(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkFiles(full));
     } else {
@@ -43750,7 +44088,7 @@ function walkFiles(dir) {
 init_esm_shims();
 import { createServer as createHttpServer } from "http";
 import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve6, join as join11, dirname as dirname2, extname as extname4 } from "path";
+import { resolve as resolve6, join as join12, dirname as dirname2, extname as extname4 } from "path";
 import { mkdir as mkdir2, writeFile as writeFile8, watch, readFile } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { createServer as createViteServer, searchForWorkspaceRoot } from "vite";
@@ -43927,26 +44265,26 @@ var handleParsingNestedValues = (form, key, value) => {
 
 // ../../node_modules/.pnpm/hono@4.12.28/node_modules/hono/dist/utils/url.js
 init_esm_shims();
-var splitPath = (path4) => {
-  const paths = path4.split("/");
+var splitPath = (path7) => {
+  const paths = path7.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path4 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path4);
+  const { groups, path: path7 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path7);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path4) => {
+var extractGroupsFromPath = (path7) => {
   const groups = [];
-  path4 = path4.replace(/\{[^}]+\}/g, (match2, index) => {
+  path7 = path7.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path4 };
+  return { groups, path: path7 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -44003,8 +44341,8 @@ var getPath = (request) => {
       const queryIndex = url2.indexOf("?", i);
       const hashIndex = url2.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path4 = url2.slice(start, end);
-      return tryDecodeURI(path4.includes("%25") ? path4.replace(/%25/g, "%2525") : path4);
+      const path7 = url2.slice(start, end);
+      return tryDecodeURI(path7.includes("%25") ? path7.replace(/%25/g, "%2525") : path7);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -44021,11 +44359,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path4) => {
-  if (path4.charCodeAt(path4.length - 1) !== 63 || !path4.includes(":")) {
+var checkOptionalParameter = (path7) => {
+  if (path7.charCodeAt(path7.length - 1) !== 63 || !path7.includes(":")) {
     return null;
   }
-  const segments = path4.split("/");
+  const segments = path7.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -44166,9 +44504,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path4 = "/", matchResult = [[]]) {
+  constructor(request, path7 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path4;
+    this.path = path7;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -44923,8 +45261,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path4, ...handlers) => {
-      for (const p2 of [path4].flat()) {
+    this.on = (method, path7, ...handlers) => {
+      for (const p2 of [path7].flat()) {
         this.#path = p2;
         for (const m2 of [method].flat()) {
           handlers.map((handler) => {
@@ -44981,8 +45319,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path4, app) {
-    const subApp = this.basePath(path4);
+  route(path7, app) {
+    const subApp = this.basePath(path7);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -45008,9 +45346,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path4) {
+  basePath(path7) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path4);
+    subApp._basePath = mergePath(this._basePath, path7);
     return subApp;
   }
   /**
@@ -45084,7 +45422,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path4, applicationHandler, options) {
+  mount(path7, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -45111,7 +45449,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path4);
+      const mergedPath = mergePath(this._basePath, path7);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url2 = new URL(request.url);
@@ -45126,19 +45464,19 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path4, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path7, "*"), handler);
     return this;
   }
-  #addRoute(method, path4, handler, baseRoutePath) {
+  #addRoute(method, path7, handler, baseRoutePath) {
     method = method.toUpperCase();
-    path4 = mergePath(this._basePath, path4);
+    path7 = mergePath(this._basePath, path7);
     const r = {
       basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-      path: path4,
+      path: path7,
       method,
       handler
     };
-    this.router.add(method, path4, [handler, r]);
+    this.router.add(method, path7, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -45151,10 +45489,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path4 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path4);
+    const path7 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path7);
     const c = new Context(request, {
-      path: path4,
+      path: path7,
       matchResult,
       env,
       executionCtx,
@@ -45261,7 +45599,7 @@ init_esm_shims();
 // ../../node_modules/.pnpm/hono@4.12.28/node_modules/hono/dist/router/reg-exp-router/matcher.js
 init_esm_shims();
 var emptyParam = [];
-function match(method, path4) {
+function match(method, path7) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path23) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -45277,7 +45615,7 @@ function match(method, path4) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path4);
+  return match2(method, path7);
 }
 
 // ../../node_modules/.pnpm/hono@4.12.28/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -45394,12 +45732,12 @@ init_esm_shims();
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path4, index, pathErrorCheckOnly) {
+  insert(path7, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path4 = path4.replace(/\{[^}]+\}/g, (m2) => {
+      path7 = path7.replace(/\{[^}]+\}/g, (m2) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m2];
         i++;
@@ -45410,7 +45748,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path4.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path7.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -45449,9 +45787,9 @@ var Trie = class {
 // ../../node_modules/.pnpm/hono@4.12.28/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path4) {
-  return wildcardRegExpCache[path4] ??= new RegExp(
-    path4 === "*" ? "" : `^${path4.replace(
+function buildWildcardRegExp(path7) {
+  return wildcardRegExpCache[path7] ??= new RegExp(
+    path7 === "*" ? "" : `^${path7.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -45473,17 +45811,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path4, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path7, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path4] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path7] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path4, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path7, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path4) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path7) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -45517,12 +45855,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path4) {
+function findMiddleware(middleware, path7) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a2, b2) => b2.length - a2.length)) {
-    if (buildWildcardRegExp(k).test(path4)) {
+    if (buildWildcardRegExp(k).test(path7)) {
       return [...middleware[k]];
     }
   }
@@ -45536,7 +45874,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path4, handler) {
+  add(method, path7, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -45551,18 +45889,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path4 === "/*") {
-      path4 = "*";
+    if (path7 === "/*") {
+      path7 = "*";
     }
-    const paramCount = (path4.match(/\/:/g) || []).length;
-    if (/\*$/.test(path4)) {
-      const re = buildWildcardRegExp(path4);
+    const paramCount = (path7.match(/\/:/g) || []).length;
+    if (/\*$/.test(path7)) {
+      const re = buildWildcardRegExp(path7);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m2) => {
-          middleware[m2][path4] ||= findMiddleware(middleware[m2], path4) || findMiddleware(middleware[METHOD_NAME_ALL], path4) || [];
+          middleware[m2][path7] ||= findMiddleware(middleware[m2], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
         });
       } else {
-        middleware[method][path4] ||= findMiddleware(middleware[method], path4) || findMiddleware(middleware[METHOD_NAME_ALL], path4) || [];
+        middleware[method][path7] ||= findMiddleware(middleware[method], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
       }
       Object.keys(middleware).forEach((m2) => {
         if (method === METHOD_NAME_ALL || method === m2) {
@@ -45580,7 +45918,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path4) || [path4];
+    const paths = checkOptionalParameter(path7) || [path7];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path23 = paths[i];
       Object.keys(routes).forEach((m2) => {
@@ -45607,13 +45945,13 @@ var RegExpRouter = class {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
     [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path4) => [path4, r[method][path4]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path7) => [path7, r[method][path7]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path4) => [path4, r[METHOD_NAME_ALL][path4]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path7) => [path7, r[METHOD_NAME_ALL][path7]])
         );
       }
     });
@@ -45640,13 +45978,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path4, handler) {
+  add(method, path7, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path4, handler]);
+    this.#routes.push([method, path7, handler]);
   }
-  match(method, path4) {
+  match(method, path7) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -45661,7 +45999,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path4);
+        res = router.match(method, path7);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -45718,10 +46056,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path4, handler) {
+  insert(method, path7, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path4);
+    const parts = splitRoutingPath(path7);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p2 = parts[i];
@@ -45770,12 +46108,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path4) {
+  search(method, path7) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path4);
+    const parts = splitPath(path7);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -45817,13 +46155,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path4[0] === "/" ? 1 : 0;
+              let offset = path7[0] === "/" ? 1 : 0;
               for (let p2 = 0; p2 < len; p2++) {
                 partOffsets[p2] = offset;
                 offset += parts[p2].length + 1;
               }
             }
-            const restPathString = path4.substring(partOffsets[i]);
+            const restPathString = path7.substring(partOffsets[i]);
             const m2 = matcher.exec(restPathString);
             if (m2) {
               params[name] = m2[0];
@@ -45876,18 +46214,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path4, handler) {
-    const results = checkOptionalParameter(path4);
+  add(method, path7, handler) {
+    const results = checkOptionalParameter(path7);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path4, handler);
+    this.#node.insert(method, path7, handler);
   }
-  match(method, path4) {
-    return this.#node.search(method, path4);
+  match(method, path7) {
+    return this.#node.search(method, path7);
   }
 };
 
@@ -46817,8 +47155,8 @@ function setAuthCookie(c, name, token, options) {
     sameSite: "Strict"
   });
 }
-function clearAuthCookie(c, name, path4) {
-  deleteCookie(c, name, path4 !== void 0 ? { path: path4 } : void 0);
+function clearAuthCookie(c, name, path7) {
+  deleteCookie(c, name, path7 !== void 0 ? { path: path7 } : void 0);
 }
 function createAuthMiddleware(db) {
   return async (c, next) => {
@@ -47324,11 +47662,11 @@ function isPublished(item) {
   return item["published"] === true;
 }
 function registerPublicContentRoutes(app, registry2, repos, projectors, paths, listRateLimit, resolver) {
-  function registerListRoute(path4, handler) {
+  function registerListRoute(path7, handler) {
     if (listRateLimit) {
-      app.get(path4, listRateLimit, handler);
+      app.get(path7, listRateLimit, handler);
     } else {
-      app.get(path4, handler);
+      app.get(path7, handler);
     }
   }
   registerListRoute(paths.collection("content"), (c) => {
@@ -49293,7 +49631,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 }
 var API_VERSION = (() => {
   try {
-    return "0.4.2";
+    return "0.4.3";
   } catch {
     return "0.0.0";
   }
@@ -49894,7 +50232,7 @@ function createCmsApp(options) {
 // src/codegen/drizzle-config.ts
 init_esm_shims();
 import { writeFile as writeFile6 } from "fs/promises";
-import { join as join8, relative as relative2, resolve as resolve4 } from "path";
+import { join as join9, relative as relative2, resolve as resolve4 } from "path";
 async function generateDrizzleConfig(config3, targetDir) {
   const migrationsFolder = config3.migrations?.folder ?? "./migrations";
   const migrationsTable = config3.migrations?.table ?? "__manguito_migrations";
@@ -49916,13 +50254,13 @@ async function generateDrizzleConfig(config3, targetDir) {
     `  tablesFilter: ['!${migrationsTable}'],`,
     `})`
   ].join("\n");
-  await writeFile6(join8(targetDir, "drizzle.config.ts"), content, "utf8");
+  await writeFile6(join9(targetDir, "drizzle.config.ts"), content, "utf8");
 }
 
 // src/codegen/nav.ts
 init_esm_shims();
 import { writeFile as writeFile7 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function schemaBasePath(name) {
   const segment = name.includes("--") ? name.slice(name.indexOf("--") + 2) : name;
   return segment.replace(/_/g, "-");
@@ -49940,17 +50278,17 @@ async function generateNav(registry2, targetDir) {
   })).sort((a2, b2) => a2.label.localeCompare(b2.label));
   const content = `export const nav = ${JSON.stringify({ contentTypes, taxonomyTypes }, null, 2)}
 `;
-  await writeFile7(join9(targetDir, "nav.ts"), content, "utf8");
+  await writeFile7(join10(targetDir, "nav.ts"), content, "utf8");
 }
 
 // src/commands/dev-routing.ts
 init_esm_shims();
 var ABSOLUTE_BACKEND_PATHS = ["/graphql"];
 function shouldBridgeToHono(url2, apiPrefix) {
-  const path4 = url2.split("?")[0] ?? "";
-  if (path4.startsWith(apiPrefix)) return true;
-  if (path4.startsWith("/admin/api")) return true;
-  return ABSOLUTE_BACKEND_PATHS.includes(path4);
+  const path7 = url2.split("?")[0] ?? "";
+  if (path7.startsWith(apiPrefix)) return true;
+  if (path7.startsWith("/admin/api")) return true;
+  return ABSOLUTE_BACKEND_PATHS.includes(path7);
 }
 
 // src/utils/db.ts
@@ -49985,7 +50323,7 @@ function createPromptAdapter() {
 init_esm_shims();
 import { existsSync as existsSync4 } from "fs";
 import { readdir } from "fs/promises";
-import { resolve as resolve5, join as join10, extname as extname3 } from "path";
+import { resolve as resolve5, join as join11, extname as extname3 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var RESOLVER_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mjs", ".js"]);
 function isProgrammaticFieldDefinition(v2) {
@@ -49994,7 +50332,7 @@ function isProgrammaticFieldDefinition(v2) {
 async function walkTsFiles(dir) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = join10(dir, entry.name);
+    const full = join11(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await walkTsFiles(full));
     } else if (RESOLVER_EXTENSIONS.has(extname3(entry.name))) {
@@ -50057,7 +50395,7 @@ async function runDev(options, deps) {
   const needsSeed = !await db.tableExists("users");
   const bootstrapRegistry = await parseAllSchemas(cwd, config3);
   await generateDrizzleConfig(config3, manguitoDir);
-  await writeFile8(join11(manguitoDir, "schema.ts"), generateSchemaFile(bootstrapRegistry), "utf8");
+  await writeFile8(join12(manguitoDir, "schema.ts"), generateSchemaFile(bootstrapRegistry), "utf8");
   await runDevMigration(drizzleConfigPath);
   printSuccess(needsSeed ? "Schema tables created" : "Schema tables up to date");
   if (needsSeed) {
@@ -50103,7 +50441,7 @@ async function runDev(options, deps) {
   );
   await generateSchemaRegistry(registry2, manguitoDir);
   await generateRoutes2(registry2, manguitoDir);
-  await generateForms(registry2, join11(manguitoDir, "forms"));
+  await generateForms(registry2, join12(manguitoDir, "forms"));
   await generateNav(registry2, manguitoDir);
   const resolverMap = await loadProgrammaticResolvers(cwd, config3.programmatic.dir);
   const adapter = createCmsApp({
@@ -50237,10 +50575,10 @@ async function onSchemaFileChange(args) {
     return;
   }
   await generateDrizzleConfig(config3, manguitoDir);
-  await writeFile8(join11(manguitoDir, "schema.ts"), generateSchemaFile(registry2), "utf8");
+  await writeFile8(join12(manguitoDir, "schema.ts"), generateSchemaFile(registry2), "utf8");
   await generateSchemaRegistry(registry2, manguitoDir);
   await generateRoutes2(registry2, manguitoDir);
-  await generateForms(registry2, join11(manguitoDir, "forms"));
+  await generateForms(registry2, join12(manguitoDir, "forms"));
   await generateNav(registry2, manguitoDir);
   try {
     await runDevMigration(drizzleConfigPath);
@@ -50305,7 +50643,7 @@ async function parseAllSchemas(cwd, config3) {
   return buildSchemaRegistry(parsedSchemas, routesResult.value, rolesResult.value);
 }
 function resolveAdminRoot2(cwd) {
-  const cwdRequire = createRequire2(join11(cwd, "package.json"));
+  const cwdRequire = createRequire2(join12(cwd, "package.json"));
   const adminPkgJson = cwdRequire.resolve("@bobbykim/manguito-cms-admin/package.json");
   return dirname2(adminPkgJson);
 }
@@ -50443,7 +50781,7 @@ async function runStart(options, deps) {
 
 // src/commands/migrate.ts
 init_esm_shims();
-import { resolve as resolve8, join as join12 } from "path";
+import { resolve as resolve8, join as join13 } from "path";
 import { readFile as readFile2 } from "fs/promises";
 function registerMigrate(program2) {
   program2.command("migrate").description("Apply pending database migrations").option("--env <path>", "path to .env file to load").option("--status", "show migration state without applying").option("--dry-run", "preview migrations without writing").option("--force", "skip destructive-change confirmation prompt").action(async (options) => {
@@ -50532,7 +50870,7 @@ async function runMigrate(options, deps) {
   const generatedDir = resolve8(cwd, "dist/generated");
   await generateDrizzleConfig(config3, generatedDir);
   const newFileNames = await generateMigration(deps.configPath, migrationsFolder);
-  const newFilePaths = newFileNames.map((f) => join12(migrationsFolder, f));
+  const newFilePaths = newFileNames.map((f) => join13(migrationsFolder, f));
   printSuccess(
     newFileNames.length === 0 ? "No new migration files generated" : `Generated ${newFileNames.length} migration file${newFileNames.length !== 1 ? "s" : ""}: ${newFileNames.join(", ")}`
   );
@@ -50960,6 +51298,333 @@ async function runUsersDemote(options, deps) {
   printSuccess(`${email3} demoted to ${targetRole.name}.`);
 }
 
+// src/commands/version.ts
+init_esm_shims();
+import fs6 from "fs";
+import path6 from "path";
+
+// src/utils/registry.ts
+init_esm_shims();
+import { resolve as resolve11 } from "path";
+
+// src/utils/schema-config.ts
+init_esm_shims();
+import { resolve as resolve10 } from "path";
+function resolveSchemaConfig(cwd, config3) {
+  return {
+    base_path: resolve10(cwd, config3.schema.base_path),
+    folders: config3.schema.folders
+  };
+}
+
+// src/utils/registry.ts
+function loadWorkingRegistry(cwd, config3, command) {
+  const schema = resolveSchemaConfig(cwd, config3);
+  const allErrors = [];
+  const parsedSchemas = [];
+  const walkResult = walkSchemaDirectory(schema);
+  if (!walkResult.ok) {
+    allErrors.push(...walkResult.errors);
+  } else {
+    for (const file2 of walkResult.value) {
+      const parseResult = parseSchema(file2.raw, file2.schema_type, file2.path);
+      if (!parseResult.ok) {
+        allErrors.push(...parseResult.errors);
+      } else {
+        parsedSchemas.push(parseResult.schema);
+      }
+    }
+  }
+  const rolesPath = resolve11(schema.base_path, "roles.json");
+  let parsedRoles = null;
+  const rolesLoad = loadSchemaFile(rolesPath);
+  if (!rolesLoad.ok) {
+    allErrors.push(...rolesLoad.errors);
+  } else {
+    const rolesParse = parseRoles(rolesLoad.value, rolesPath);
+    if (!rolesParse.ok) allErrors.push(...rolesParse.errors);
+    else parsedRoles = rolesParse.value;
+  }
+  const routesPath = resolve11(schema.base_path, "routes.json");
+  let parsedRoutes = null;
+  const routesLoad = loadSchemaFile(routesPath);
+  if (!routesLoad.ok) {
+    allErrors.push(...routesLoad.errors);
+  } else {
+    const routesParse = parseRoutes(routesLoad.value, routesPath);
+    if (!routesParse.ok) allErrors.push(...routesParse.errors);
+    else parsedRoutes = routesParse.value;
+  }
+  if (allErrors.length > 0 || parsedRoles === null || parsedRoutes === null) {
+    printValidationErrors(allErrors, "Schema parse errors", command);
+    process.exit(1);
+  }
+  return buildSchemaRegistry(parsedSchemas, parsedRoutes, parsedRoles);
+}
+
+// src/commands/version-report.ts
+init_esm_shims();
+function formatField(change) {
+  switch (change.kind) {
+    case "added":
+      return `  + ${change.name}  ${change.field_type}  new`;
+    case "renamed":
+      return `  ~ ${change.to_name}  was "${change.from_name}"  \u2192 column ${change.column}`;
+    case "tombstoned": {
+      const fallback = change.fallback === void 0 ? "" : `, fallback ${JSON.stringify(change.fallback)}`;
+      return `  \u2298 ${change.name}  tombstoned  \u2192 column ${change.column} retained${fallback}`;
+    }
+    case "restored":
+      return `  \u21BA ${change.name}  restored  \u2192 column ${change.column} exposed again`;
+  }
+}
+function formatSchemaChange(change) {
+  const header = change.from === null ? `Working schema \u2014 nothing has been cut yet, so ${change.to} would be the first version` : `Working schema vs ${change.from} (highest snapshot) \u2014 would become ${change.to}`;
+  if (change.identical) {
+    return `${header}
+
+No column added, renamed, tombstoned or restored.`;
+  }
+  const blocks = change.types.map((type) => {
+    const label = type.status === "added" ? `${type.type}  (new type)` : type.type;
+    if (type.fields.length === 0) return `${label}
+  (no changes)`;
+    return [label, ...type.fields.map(formatField)].join("\n");
+  });
+  return [header, "", ...blocks].join("\n");
+}
+
+// src/commands/version-fs.ts
+init_esm_shims();
+import fs5 from "fs";
+import path5 from "path";
+var SUPPORTED = /* @__PURE__ */ new Set([".json", ".yaml", ".yml"]);
+function copySnapshotFolders(input2) {
+  const { fromRoot, toDir, folders } = input2;
+  for (const folder of Object.values(folders)) {
+    const src = path5.join(fromRoot, folder);
+    if (!fs5.existsSync(src) || !fs5.statSync(src).isDirectory()) continue;
+    const dest = path5.join(toDir, folder);
+    fs5.mkdirSync(dest, { recursive: true });
+    for (const entry of fs5.readdirSync(src)) {
+      if (!SUPPORTED.has(path5.extname(entry).toLowerCase())) continue;
+      fs5.copyFileSync(path5.join(src, entry), path5.join(dest, entry));
+    }
+  }
+}
+function retireSnapshotDir(versionsDir, version3) {
+  const from = path5.join(versionsDir, version3);
+  const staging = path5.join(versionsDir, `.${version3}.removing`);
+  fs5.rmSync(staging, { recursive: true, force: true });
+  fs5.renameSync(from, staging);
+  fs5.rmSync(staging, { recursive: true, force: true });
+}
+function writeSnapshotAtomically(input2) {
+  const { fromRoot, versionsDir, version: version3, folders } = input2;
+  const target = path5.join(versionsDir, version3);
+  const staging = path5.join(versionsDir, `.${version3}.tmp`);
+  fs5.rmSync(staging, { recursive: true, force: true });
+  try {
+    copySnapshotFolders({ fromRoot, toDir: staging, folders });
+    fs5.renameSync(staging, target);
+  } catch (err) {
+    fs5.rmSync(staging, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+// src/commands/version.ts
+function highestSnapshot(snapshots) {
+  let best = null;
+  let bestN = -1;
+  for (const s of snapshots) {
+    const n = Number.parseInt(s.version.replace(/^v/, ""), 10);
+    if (Number.isNaN(n) || n <= bestN) continue;
+    best = s;
+    bestN = n;
+  }
+  return best;
+}
+async function loadVersionContext(options, deps, command) {
+  loadEnvFile(options.env);
+  const config3 = await resolveConfig(deps.cwd);
+  const schema = resolveSchemaConfig(deps.cwd, config3);
+  const registry2 = loadWorkingRegistry(deps.cwd, config3, command);
+  const snapshots = loadVersionSnapshots(schema, registry2);
+  if (!snapshots.ok) {
+    printValidationErrors(snapshots.errors, "Snapshot errors", command);
+    process.exit(1);
+  }
+  const model = computeVersionModel({ current: registry2, snapshots: snapshots.value });
+  if (!model.ok) {
+    printValidationErrors(model.errors, "Version model errors", command);
+    process.exit(1);
+  }
+  return { schema, registry: registry2, snapshots: snapshots.value, model: model.value };
+}
+function orphanedTombstoneErrors(input2) {
+  const remaining = input2.snapshots.filter((s) => s.version !== input2.retiring);
+  const model = computeVersionModel({ current: input2.registry, snapshots: remaining });
+  if (model.ok) return [];
+  return model.errors.filter((e) => e.code === "ORPHANED_TOMBSTONE");
+}
+function registerVersion(program2) {
+  program2.command("version:diff").description("Show what cutting a new version would freeze").option("--env <path>", "path to .env file to load").action(async (options) => {
+    await runVersionDiff(options, { cwd: process.cwd() });
+  });
+  program2.command("version:cut").description("Freeze the working schema as a new version").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (options) => {
+    await runVersionCut(options, { cwd: process.cwd(), prompt: createPromptAdapter() });
+  });
+  program2.command("version:retire <version>").description("Stop serving a cut version and delete its snapshot").option("--env <path>", "path to .env file to load").option("--yes", "skip the confirmation prompt").action(async (version3, options) => {
+    await runVersionRetire(version3, options, { cwd: process.cwd(), prompt: createPromptAdapter() });
+  });
+}
+async function runVersionDiff(options, deps) {
+  const ctx = await loadVersionContext(options, deps, "manguito version:diff");
+  const from = highestSnapshot(ctx.snapshots);
+  const change = describeSchemaChange({
+    from,
+    to: { version: ctx.model.current, registry: ctx.registry }
+  });
+  process.stdout.write(`${formatSchemaChange(change)}
+`);
+  if (change.identical) {
+    process.stdout.write(
+      `
+Nothing to cut \u2014 no column was added, renamed, tombstoned or restored, so ${ctx.model.current} would expose the same contract.
+`
+    );
+    return;
+  }
+  printSuccess(`Cutting now would create ${ctx.schema.base_path}/versions/${ctx.model.current}/`);
+}
+async function runVersionCut(options, deps) {
+  const ctx = await loadVersionContext(options, deps, "manguito version:cut");
+  const from = highestSnapshot(ctx.snapshots);
+  const version3 = ctx.model.current;
+  const change = describeSchemaChange({
+    from,
+    to: { version: version3, registry: ctx.registry }
+  });
+  if (change.identical) {
+    printGuidedError(
+      `No column was added, renamed, tombstoned or restored since ${from?.version ?? "the last cut"} \u2014 cutting ${version3} would freeze an identical contract.`,
+      "Changes to paragraph, programmatic, many-to-many and enum definitions are not versioned and need no new version. A live version commits you to retaining every column it exposes, so cut only when a column actually changed \u2014 or run `manguito version:retire <version>` if you meant to shrink the live set."
+    );
+    process.exit(1);
+  }
+  const versionsDir = path6.join(ctx.schema.base_path, "versions");
+  const target = path6.join(versionsDir, version3);
+  if (fs6.existsSync(target)) {
+    printGuidedError(
+      `${target} already exists.`,
+      "A snapshot directory is never overwritten. Remove or rename it, then run version:cut again."
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${formatSchemaChange(change)}
+
+`);
+  const live = [...ctx.model.live.filter((v2) => v2 !== version3), version3].join(" ");
+  process.stdout.write(
+    `After cutting, ${live} are live. Every column those versions expose must stay in the
+schema \u2014 as a live field or a tombstone \u2014 until you retire them.
+
+`
+  );
+  if (options.yes !== true) {
+    const ok = await deps.prompt.confirm(`Freeze the working schema as ${version3}?`);
+    if (!ok) {
+      process.stdout.write("Cancelled. Nothing was written.\n");
+      return;
+    }
+  }
+  try {
+    writeSnapshotAtomically({ fromRoot: ctx.schema.base_path, versionsDir, version: version3, folders: ctx.schema.folders });
+  } catch (err) {
+    printGuidedError(
+      `Failed to write ${target}: ${err instanceof Error ? err.message : String(err)}`,
+      "Nothing was left behind \u2014 the snapshot is written to a temporary directory and renamed into place only once it is complete."
+    );
+    process.exit(1);
+  }
+  printSuccess(`Froze the working schema as ${version3} at ${target}`);
+  process.stdout.write(`Live: ${live}.  Working schema is now v${Number.parseInt(version3.slice(1), 10) + 1}.
+`);
+}
+async function runVersionRetire(version3, options, deps) {
+  if (!/^v\d+$/.test(version3)) {
+    printGuidedError(`"${version3}" is not a version name.`, "Expected v<number>, for example v1.");
+    process.exit(1);
+  }
+  const ctx = await loadVersionContext(options, deps, "manguito version:retire");
+  if (!ctx.snapshots.some((s) => s.version === version3)) {
+    const existing = ctx.snapshots.map((s) => s.version).join(", ");
+    printGuidedError(
+      `${version3} is not a cut version.`,
+      existing === "" ? "No versions have been cut yet \u2014 run `manguito version:cut` first." : `Cut versions: ${existing}.`
+    );
+    process.exit(1);
+  }
+  const highest = highestSnapshot(ctx.snapshots);
+  if (highest !== null && highest.version === version3) {
+    const target = path6.join(ctx.schema.base_path, "versions", version3);
+    printGuidedError(
+      `${version3} is the newest cut version and cannot be retired.`,
+      `The working schema is ${ctx.model.current} because ${version3} is the highest snapshot \u2014 retiring it would renumber the working schema back onto ${version3}, and anyone pinned to ${version3} would get a different contract. Cutting a version with a real contract change makes ${version3} retirable. If ${version3} was cut in error, delete ${target} by hand \u2014 safe only while nothing yet consumes ${version3}, since deleting the newest snapshot renumbers the working schema back onto it.`
+    );
+    process.exit(1);
+  }
+  const orphans = orphanedTombstoneErrors({
+    registry: ctx.registry,
+    snapshots: ctx.snapshots,
+    retiring: version3
+  });
+  process.stdout.write(`Retiring ${version3} will delete ${path6.join(ctx.schema.base_path, "versions", version3)}
+
+`);
+  if (orphans.length > 0) {
+    process.stdout.write(
+      `${orphans.length} tombstone${orphans.length === 1 ? "" : "s"} will be orphaned \u2014 their columns are no
+longer exposed by any live version. You must then delete these fields:
+
+`
+    );
+    for (const o of orphans) {
+      process.stdout.write(`  ${o.file}
+    ${o.message}
+
+`);
+    }
+    process.stdout.write(
+      "Until you do, `manguito validate` will report ORPHANED_TOMBSTONE. Deleting them\nshrinks the union and lets the next migration DROP those columns.\n\n"
+    );
+  }
+  if (options.yes !== true) {
+    const ok = await deps.prompt.confirm(`Retire ${version3}?`);
+    if (!ok) {
+      process.stdout.write("Cancelled. Nothing was deleted.\n");
+      return;
+    }
+  }
+  const versionsDir = path6.join(ctx.schema.base_path, "versions");
+  try {
+    retireSnapshotDir(versionsDir, version3);
+  } catch (err) {
+    printGuidedError(
+      `Failed to retire ${version3}: ${err instanceof Error ? err.message : String(err)}`,
+      "The snapshot is renamed out of the way before it is deleted, so the version is either fully retired or untouched."
+    );
+    process.exit(1);
+  }
+  printSuccess(`Retired ${version3}`);
+  if (orphans.length > 0) {
+    process.stdout.write(`
+Delete the ${orphans.length} orphaned tombstone field(s) listed above.
+`);
+  }
+}
+
 // src/index.ts
 var require2 = createRequire3(import.meta.url);
 var { version: version2 } = require2("../package.json");
@@ -50971,6 +51636,7 @@ registerMigrate(program);
 registerValidate(program);
 registerCreateSuperuser(program);
 registerUsers(program);
+registerVersion(program);
 program.parse();
 /*! Bundled license information: