@bobbykim/manguito-cms-cli 0.4.5 → 0.5.0

package/dist/index.js

@@ -38,7 +38,7 @@ import {
   resolveRelationField,
   sql,
   tracer
-} from "./chunk-UNBMPHIT.js";
+} from "./chunk-LFMOJRYP.js";
 
 // ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
@@ -119,17 +119,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path3) {
-      const ctrl = callVisitor(key, node, visitor, path3);
+    function visit_(key, node, visitor, path7) {
+      const ctrl = callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path3, ctrl);
-        return visit_(key, ctrl, visitor, path3);
+        replaceNode(key, path7, ctrl);
+        return visit_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path3 = Object.freeze(path3.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, path3);
+            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)) {
-          path3 = Object.freeze(path3.concat(node));
-          const ck = visit_("key", node.key, visitor, path3);
+          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, path3);
+          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, path3) {
-      const ctrl = await callVisitor(key, node, visitor, path3);
+    async function visitAsync_(key, node, visitor, path7) {
+      const ctrl = await callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path3, ctrl);
-        return visitAsync_(key, ctrl, visitor, path3);
+        replaceNode(key, path7, ctrl);
+        return visitAsync_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path3 = Object.freeze(path3.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, path3);
+            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)) {
-          path3 = Object.freeze(path3.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path3);
+          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, path3);
+          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, path3) {
+    function callVisitor(key, node, visitor, path7) {
       if (typeof visitor === "function")
-        return visitor(key, node, path3);
+        return visitor(key, node, path7);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path3);
+        return visitor.Map?.(key, node, path7);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path3);
+        return visitor.Seq?.(key, node, path7);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path3);
+        return visitor.Pair?.(key, node, path7);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path3);
+        return visitor.Scalar?.(key, node, path7);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path3);
+        return visitor.Alias?.(key, node, path7);
       return void 0;
     }
-    function replaceNode(key, path3, node) {
-      const parent = path3[path3.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, path3, value) {
+    function collectionFromPath(schema, path7, value) {
       let v2 = value;
-      for (let i = path3.length - 1; i >= 0; --i) {
-        const k = path3[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 = (path3) => path3 == null || typeof path3 === "object" && !!path3[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(path3, value) {
-        if (isEmptyPath(path3))
+      addIn(path7, value) {
+        if (isEmptyPath(path7))
           this.add(value);
         else {
-          const [key, ...rest] = path3;
+          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(path3) {
-        const [key, ...rest] = path3;
+      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(path3, keepScalar) {
-        const [key, ...rest] = path3;
+      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(path3) {
-        const [key, ...rest] = path3;
+      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(path3, value) {
-        const [key, ...rest] = path3;
+      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(path3, value) {
+      addIn(path7, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path3, 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(path3) {
-        if (Collection.isEmptyPath(path3)) {
+      deleteIn(path7) {
+        if (Collection.isEmptyPath(path7)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path3) : 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(path3, keepScalar) {
-        if (Collection.isEmptyPath(path3))
+      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(path3, 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(path3) {
-        if (Collection.isEmptyPath(path3))
+      hasIn(path7) {
+        if (Collection.isEmptyPath(path7))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path3) : 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(path3, value) {
-        if (Collection.isEmptyPath(path3)) {
+      setIn(path7, value) {
+        if (Collection.isEmptyPath(path7)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path3), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path3, 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, path3) => {
+    visit.itemAtPath = (cst, path7) => {
       let item = cst;
-      for (const [field, index] of path3) {
+      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, path3) => {
-      const parent = visit.itemAtPath(cst, path3.slice(0, -1));
-      const field = path3[path3.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(path3, item, visitor) {
-      let ctrl = visitor(item, path3);
+    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(path3.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, path3);
+            ctrl = ctrl(item, path7);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path3) : 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 fs3 = this.flowScalar(this.type);
+              const fs7 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map2.items.push({ start, key: fs3, sep: [] });
+                map2.items.push({ start, key: fs7, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs3);
+                this.stack.push(fs7);
               } else {
-                Object.assign(it2, { key: fs3, 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 fs3 = this.flowScalar(this.type);
+              const fs7 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs3, sep: [] });
+                fc.items.push({ start: [], key: fs7, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs3);
+                this.stack.push(fs7);
               else
-                Object.assign(it2, { key: fs3, 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 fs3 = 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 = fs3.readFileSync(config3.sslcert).toString();
+        config3.ssl.cert = fs7.readFileSync(config3.sslcert).toString();
       }
       if (config3.sslkey) {
-        config3.ssl.key = fs3.readFileSync(config3.sslkey).toString();
+        config3.ssl.key = fs7.readFileSync(config3.sslkey).toString();
       }
       if (config3.sslrootcert) {
-        config3.ssl.ca = fs3.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 path3 = __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 ? path3.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path3.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 path3 = __require("path");
-    var fs3 = __require("fs");
+    var path7 = __require("path");
+    var fs7 = __require("fs");
     var helper = require_helper();
     module.exports = function(connInfo, cb) {
       var file2 = helper.getFileName();
-      fs3.stat(file2, function(err, stat) {
+      fs7.stat(file2, function(err, stat) {
         if (err || !helper.usePgPass(stat, file2)) {
           return cb(void 0);
         }
-        var st = fs3.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, path3) {
-  if (!path3)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path3.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(path3, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    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, path3 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...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, path3 = []) => {
+  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 }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...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 path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  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 path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.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 (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29088,9 +29088,13 @@ config(en_default());
 
 // ../core/dist/index.mjs
 var import_yaml = __toESM(require_dist(), 1);
+import * as fs2 from "fs";
+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,
@@ -29119,7 +29123,19 @@ var refTargetMachineName = external_exports.string().regex(
 var RawFieldBase = external_exports.object({
   name: snakeCaseName,
   label: external_exports.string().min(1),
-  required: external_exports.boolean()
+  required: external_exports.boolean(),
+  // ─── Version declarations ───────────────────────────────────────────────────
+  //
+  // A field's storage column is STATED here, never derived from a rename
+  // history. All three are optional and default to the pre-versioning
+  // behaviour, so every schema authored before versioning existed keeps its
+  // exact meaning.
+  /** Storage column. Defaults to `name`. Stating it is how a rename works: the name changes, the column does not. */
+  column: snakeCaseName.optional(),
+  /** Tombstone — the column is retained for older live versions, and this version does not expose it. */
+  removed: external_exports.boolean().optional(),
+  /** Value served for rows created after the removal. Meaningful only on a tombstone. */
+  fallback: external_exports.unknown().optional()
 });
 var RawTextPlainFieldSchema = RawFieldBase.extend({
   type: external_exports.literal("text/plain"),
@@ -29456,6 +29472,17 @@ var FOLDER_KEY_TO_SCHEMA_TYPE = {
   taxonomy_types: "taxonomy-type",
   enum_types: "enum-type"
 };
+function directoryExists(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isSupportedExtension(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return ext === ".json" || ext === ".yaml" || ext === ".yml";
+}
 var SCHEMA_TYPE_TO_PREFIX = {
   "content-type": "content",
   "paragraph-type": "paragraph",
@@ -29465,7 +29492,7 @@ var SCHEMA_TYPE_TO_PREFIX = {
 function loadSchemaFile(filePath) {
   let raw2;
   try {
-    raw2 = fs.readFileSync(filePath, "utf-8");
+    raw2 = fs2.readFileSync(filePath, "utf-8");
   } catch (err) {
     return {
       ok: false,
@@ -29478,7 +29505,7 @@ function loadSchemaFile(filePath) {
       ]
     };
   }
-  const ext = path.extname(filePath).toLowerCase();
+  const ext = path2.extname(filePath).toLowerCase();
   if (ext === ".json") {
     try {
       return { ok: true, value: JSON.parse(raw2) };
@@ -29540,7 +29567,7 @@ function walkSchemaDirectory(config3) {
   const resolvedFolderPaths = /* @__PURE__ */ new Map();
   for (const folderKey of Object.keys(FOLDER_KEY_TO_SCHEMA_TYPE)) {
     const folderName = config3.folders[folderKey];
-    const absFolder = path.resolve(config3.base_path, folderName);
+    const absFolder = path2.resolve(config3.base_path, folderName);
     const existing = resolvedFolderPaths.get(absFolder);
     if (existing !== void 0) {
       errors.push({
@@ -29557,7 +29584,7 @@ function walkSchemaDirectory(config3) {
     FOLDER_KEY_TO_SCHEMA_TYPE
   )) {
     const folderName = config3.folders[folderKey];
-    const folderPath = path.resolve(config3.base_path, folderName);
+    const folderPath = path2.resolve(config3.base_path, folderName);
     if (!directoryExists(folderPath)) {
       errors.push({
         file: folderPath,
@@ -29570,8 +29597,8 @@ function walkSchemaDirectory(config3) {
     const expectedPrefix = SCHEMA_TYPE_TO_PREFIX[schemaType];
     for (const entry of entries) {
       if (!isSupportedExtension(entry)) continue;
-      const filePath = path.join(folderPath, entry);
-      const baseName = path.basename(entry, path.extname(entry));
+      const filePath = path2.join(folderPath, entry);
+      const baseName = path2.basename(entry, path2.extname(entry));
       if (!hasCorrectPrefix(baseName, expectedPrefix)) {
         errors.push({
           file: filePath,
@@ -29591,24 +29618,13 @@ function walkSchemaDirectory(config3) {
   if (errors.length > 0) return { ok: false, errors };
   return { ok: true, value: files };
 }
-function directoryExists(dirPath) {
-  try {
-    return fs.statSync(dirPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
 function readDirEntries(dirPath) {
   try {
-    return fs.readdirSync(dirPath);
+    return fs2.readdirSync(dirPath);
   } catch {
     return [];
   }
 }
-function isSupportedExtension(filename) {
-  const ext = path.extname(filename).toLowerCase();
-  return ext === ".json" || ext === ".yaml" || ext === ".yml";
-}
 function hasCorrectPrefix(baseName, expectedPrefix) {
   return baseName.startsWith(`${expectedPrefix}--`);
 }
@@ -29791,6 +29807,10 @@ var fieldTypeRegistry = {
     ui_component: { component: "computed-display" }
   })
 };
+function isColumnBacked2(field) {
+  const col = field.db_column;
+  return col !== null && col.column_name !== "" && !col.junction;
+}
 var CONTENT_SYSTEM_FIELDS = [
   { name: "id", db_type: "uuid", primary_key: true, default: "gen_random_uuid()", nullable: false },
   { name: "slug", db_type: "varchar", nullable: false },
@@ -29821,8 +29841,8 @@ function getNameSegment(machineName) {
   const idx = machineName.indexOf("--");
   return idx === -1 ? machineName : machineName.slice(idx + 2);
 }
-function zodPathToString(path23) {
-  return path23.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;
   }, "");
@@ -29858,6 +29878,61 @@ function checkDuplicateFieldNames(fields, sourceFile, schemaName) {
   }
   return errors;
 }
+function hasStorageColumn(f) {
+  if (f.type === "paragraph" || f.type === "programmatic") return false;
+  if (f.type === "reference" && f.rel === "many-to-many") return false;
+  return true;
+}
+function checkDuplicateColumns(fields, sourceFile, schemaName) {
+  const owner = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const f of fields) {
+    if (!hasStorageColumn(f)) continue;
+    const column = f.column ?? f.name;
+    const first = owner.get(column);
+    if (first !== void 0) {
+      errors.push({
+        file: sourceFile,
+        code: "DUPLICATE_COLUMN",
+        message: `Fields "${first}" and "${f.name}" in schema "${schemaName}" both resolve to column "${column}". One column backs exactly one field. If "${f.name}" replaced "${first}", delete the old field instead of keeping both; if they are genuinely different fields, give one an explicit "column".`
+      });
+      continue;
+    }
+    owner.set(column, f.name);
+  }
+  return errors;
+}
+function checkFieldDeclarations(rawField, built, sourceFile, schemaName) {
+  const errors = [];
+  const tombstone = rawField.removed === true;
+  if (!isColumnBacked2(built) && (rawField.column !== void 0 || tombstone)) {
+    const declaredKeys = [
+      ...rawField.column !== void 0 ? ['"column"'] : [],
+      ...tombstone ? ['"removed"'] : []
+    ];
+    const declared = declaredKeys.join(" and ");
+    errors.push({
+      file: sourceFile,
+      code: "UNRENAMEABLE_FIELD_KIND",
+      message: `Field "${rawField.name}" in "${schemaName}" declares ${declared}, but a ${rawField.type} field has no storage column of its own \u2014 its name already is its identity, so there is nothing to rename or retain. Remove the declaration.`
+    });
+  }
+  if (tombstone && rawField.required) {
+    errors.push({
+      file: sourceFile,
+      code: "TOMBSTONE_REQUIRED",
+      message: `Field "${rawField.name}" in "${schemaName}" is marked both "removed" and "required". A tombstone retains a column nothing writes any more, so a required tombstone can never be satisfied. Set "required": false, or remove "removed" to bring the field back.`
+    });
+  }
+  if (rawField.fallback !== void 0 && !tombstone) {
+    errors.push({
+      file: sourceFile,
+      code: "FALLBACK_WITHOUT_TOMBSTONE",
+      message: `Field "${rawField.name}" in "${schemaName}" declares a "fallback" but is not marked "removed": true. A fallback is the value served for rows created after a removal, so it is meaningful only on a tombstone. Add "removed": true, or remove the fallback.`
+    });
+  }
+  return errors;
+}
 function buildParsedField(rawField, order, sourceFile, ownerTableName) {
   const build = fieldTypeRegistry[rawField.type];
   if (!build) {
@@ -29871,20 +29946,40 @@ function buildParsedField(rawField, order, sourceFile, ownerTableName) {
     };
   }
   const { name, label } = rawField;
-  const { validation, db_column, ui_component } = build(rawField, { ownerTableName });
+  const built = build(rawField, { ownerTableName });
+  const declErrors = checkFieldDeclarations(rawField, built, sourceFile, ownerTableName);
+  if (declErrors.length > 0) return { ok: false, errors: declErrors };
+  const { validation, ui_component } = built;
   const required2 = validation.required;
+  const tombstone = rawField.removed === true;
+  let db_column = built.db_column;
+  if (isColumnBacked2(built)) {
+    db_column = {
+      ...db_column,
+      column_name: rawField.column ?? db_column.column_name,
+      // A tombstone is always nullable, overriding the builder — including
+      // `boolean`, the one type whose column is otherwise always NOT NULL.
+      // Rows written after the removal cannot populate the column.
+      ...tombstone && { nullable: true }
+    };
+  }
   return {
     ok: true,
     value: {
       name,
       label,
       field_type: rawField.type,
-      required: required2,
-      nullable: !required2,
+      // Nothing writes a tombstone, so it can be neither required nor NOT NULL.
+      required: tombstone ? false : required2,
+      nullable: tombstone ? true : !required2,
       order,
-      validation,
+      validation: tombstone ? { ...validation, required: false } : validation,
       db_column,
-      ui_component
+      ui_component,
+      // Omitted entirely when absent, never set to `false`/`undefined`: an
+      // ordinary field must be byte-identical to its pre-versioning shape.
+      ...tombstone && { removed: true },
+      ...rawField.fallback !== void 0 && { fallback: rawField.fallback }
     }
   };
 }
@@ -29918,7 +30013,10 @@ function parseContentType(raw2, sourceFile) {
     }
     tabs.push({ name: tab.name, label: tab.label, fields: tabFieldNames });
   }
-  const dupErrors = checkDuplicateFieldNames(flatRawFields, sourceFile, v2.name);
+  const dupErrors = [
+    ...checkDuplicateFieldNames(flatRawFields, sourceFile, v2.name),
+    ...checkDuplicateColumns(flatRawFields, sourceFile, v2.name)
+  ];
   if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
   const tableName = machineNameToTableName(v2.name);
   const { fields, errors } = buildFields(flatRawFields, sourceFile, tableName);
@@ -29968,7 +30066,10 @@ function parseParagraphType(raw2, sourceFile) {
     return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
   }
   const v2 = result.data;
-  const dupErrors = checkDuplicateFieldNames(v2.fields, sourceFile, v2.name);
+  const dupErrors = [
+    ...checkDuplicateFieldNames(v2.fields, sourceFile, v2.name),
+    ...checkDuplicateColumns(v2.fields, sourceFile, v2.name)
+  ];
   if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
   const tableName = machineNameToTableName(v2.name);
   const { fields, errors } = buildFields(v2.fields, sourceFile, tableName);
@@ -29990,7 +30091,10 @@ function parseTaxonomyType(raw2, sourceFile) {
     return { ok: false, errors: zodErrorsToParseErrors(result.error, sourceFile) };
   }
   const v2 = result.data;
-  const dupErrors = checkDuplicateFieldNames(v2.fields, sourceFile, v2.name);
+  const dupErrors = [
+    ...checkDuplicateFieldNames(v2.fields, sourceFile, v2.name),
+    ...checkDuplicateColumns(v2.fields, sourceFile, v2.name)
+  ];
   if (dupErrors.length > 0) return { ok: false, errors: dupErrors };
   const tableName = machineNameToTableName(v2.name);
   const { fields, errors } = buildFields(v2.fields, sourceFile, tableName);
@@ -30159,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();
@@ -30365,7 +30805,7 @@ init_esm_shims();
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path3, field }, columnIndex) => {
+    (result2, { path: path7, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -30377,8 +30817,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path3.entries()) {
-        if (pathChunkIndex < path3.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path7.entries()) {
+        if (pathChunkIndex < path7.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -30386,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) && path3.length === 2) {
-            const objectName = path3[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)) {
@@ -33755,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) {
@@ -34979,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") {
@@ -35075,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;
           }
         }
@@ -38842,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 fs3(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");
@@ -38850,9 +39290,9 @@ var ds = T((th, ps) => {
       return [t, n];
     }));
   }
-  a(fs3, "parseAttributePairs");
+  a(fs7, "parseAttributePairs");
   function qu(r) {
-    let e = fs3(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");
@@ -38869,7 +39309,7 @@ var ds = T((th, ps) => {
   }
   a(qu, "parseServerFirstMessage");
   function Qu(r) {
-    let t = fs3(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");
@@ -41605,8 +42045,8 @@ function drizzle2(...params) {
 // ../db/dist/index.mjs
 import { execSync, spawnSync } from "child_process";
 import crypto2 from "crypto";
-import path2 from "path";
-import fs2 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 = {}) {
@@ -42092,32 +42532,32 @@ async function seedSystemTables(db, registry2, options = {}) {
 }
 function resolvedPathEnv() {
   const root = process.cwd();
-  const localBin = path2.join(root, "node_modules", ".bin");
-  const existing = (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean).map((entry) => path2.isAbsolute(entry) ? entry : path2.resolve(root, entry));
-  return { ...process.env, PATH: [localBin, ...existing].join(path2.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: path2.dirname(configPath),
+    cwd: path4.dirname(configPath),
     env: resolvedPathEnv()
   });
 }
 async function generateMigration(configPath, migrationsFolder) {
   let beforeFiles = [];
   try {
-    const entries = await fs2.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: path2.dirname(configPath),
+    cwd: path4.dirname(configPath),
     env: resolvedPathEnv()
   });
   let afterFiles = [];
   try {
-    const entries = await fs2.readdir(migrationsFolder);
+    const entries = await fs4.readdir(migrationsFolder);
     afterFiles = entries.filter((f) => f.endsWith(".sql"));
   } catch {
   }
@@ -42138,16 +42578,16 @@ async function applyMigrations(configPath, db, options) {
   if (statusBefore.pending.length > 0) {
     let journalEntries = [];
     try {
-      const journalPath = path2.join(migrationsFolder, "meta", "_journal.json");
-      const raw2 = await fs2.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 = path2.join(migrationsFolder, pendingFile);
+      const sqlPath = path4.join(migrationsFolder, pendingFile);
       let sqlContent;
       try {
-        sqlContent = await fs2.readFile(sqlPath, "utf-8");
+        sqlContent = await fs4.readFile(sqlPath, "utf-8");
       } catch {
         continue;
       }
@@ -42177,7 +42617,7 @@ async function applyMigrations(configPath, db, options) {
     "drizzle-kit",
     ["migrate", `--config=${configPath}`],
     {
-      cwd: path2.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.
@@ -42203,8 +42643,8 @@ async function getMigrationStatus(db, options) {
   const { migrationsTable, migrationsFolder } = options;
   let journalEntries;
   try {
-    const journalPath = path2.join(migrationsFolder, "meta", "_journal.json");
-    const raw2 = await fs2.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 {
@@ -42302,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();
@@ -42985,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();
@@ -43082,7 +43522,7 @@ function renderField(field, indent) {
   return lines.join("\n");
 }
 function generateFormComponent(schema) {
-  const { fields } = schema;
+  const fields = schema.fields.filter((f) => f.removed !== true);
   const neededComponents = /* @__PURE__ */ new Set();
   const paragraphRefs = [];
   const seenRefs = /* @__PURE__ */ new Set();
@@ -43132,7 +43572,9 @@ function generateFormComponent(schema) {
     for (const tab of schema.ui.tabs) {
       templateLines.push(`    <Tab name="${escAttr(tab.name)}" label="${escAttr(tab.label)}">`);
       for (const fieldName of tab.fields) {
-        templateLines.push(renderField(fieldByName.get(fieldName), "      "));
+        const field = fieldByName.get(fieldName);
+        if (!field) continue;
+        templateLines.push(renderField(field, "      "));
       }
       templateLines.push("    </Tab>");
     }
@@ -43157,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() {
@@ -43353,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}`;
@@ -43375,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
@@ -43555,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);
@@ -43625,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 {
@@ -43646,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 extname3 } 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";
@@ -43823,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 = (path3) => {
-  const paths = path3.split("/");
+var splitPath = (path7) => {
+  const paths = path7.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path3 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path3);
+  const { groups, path: path7 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path7);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path3) => {
+var extractGroupsFromPath = (path7) => {
   const groups = [];
-  path3 = path3.replace(/\{[^}]+\}/g, (match2, index) => {
+  path7 = path7.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path3 };
+  return { groups, path: path7 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -43899,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 path3 = url2.slice(start, end);
-      return tryDecodeURI(path3.includes("%25") ? path3.replace(/%25/g, "%2525") : path3);
+      const path7 = url2.slice(start, end);
+      return tryDecodeURI(path7.includes("%25") ? path7.replace(/%25/g, "%2525") : path7);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -43917,11 +44359,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path3) => {
-  if (path3.charCodeAt(path3.length - 1) !== 63 || !path3.includes(":")) {
+var checkOptionalParameter = (path7) => {
+  if (path7.charCodeAt(path7.length - 1) !== 63 || !path7.includes(":")) {
     return null;
   }
-  const segments = path3.split("/");
+  const segments = path7.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -44062,9 +44504,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path3 = "/", matchResult = [[]]) {
+  constructor(request, path7 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path3;
+    this.path = path7;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -44819,8 +45261,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path3, ...handlers) => {
-      for (const p2 of [path3].flat()) {
+    this.on = (method, path7, ...handlers) => {
+      for (const p2 of [path7].flat()) {
         this.#path = p2;
         for (const m2 of [method].flat()) {
           handlers.map((handler) => {
@@ -44877,8 +45319,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path3, app) {
-    const subApp = this.basePath(path3);
+  route(path7, app) {
+    const subApp = this.basePath(path7);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -44904,9 +45346,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path3) {
+  basePath(path7) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path3);
+    subApp._basePath = mergePath(this._basePath, path7);
     return subApp;
   }
   /**
@@ -44980,7 +45422,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path3, applicationHandler, options) {
+  mount(path7, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -45007,7 +45449,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path3);
+      const mergedPath = mergePath(this._basePath, path7);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url2 = new URL(request.url);
@@ -45022,19 +45464,19 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path3, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path7, "*"), handler);
     return this;
   }
-  #addRoute(method, path3, handler, baseRoutePath) {
+  #addRoute(method, path7, handler, baseRoutePath) {
     method = method.toUpperCase();
-    path3 = mergePath(this._basePath, path3);
+    path7 = mergePath(this._basePath, path7);
     const r = {
       basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-      path: path3,
+      path: path7,
       method,
       handler
     };
-    this.router.add(method, path3, [handler, r]);
+    this.router.add(method, path7, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -45047,10 +45489,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path3 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path3);
+    const path7 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path7);
     const c = new Context(request, {
-      path: path3,
+      path: path7,
       matchResult,
       env,
       executionCtx,
@@ -45157,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, path3) {
+function match(method, path7) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path23) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -45173,7 +45615,7 @@ function match(method, path3) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path3);
+  return match2(method, path7);
 }
 
 // ../../node_modules/.pnpm/hono@4.12.28/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -45290,12 +45732,12 @@ init_esm_shims();
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path3, index, pathErrorCheckOnly) {
+  insert(path7, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path3 = path3.replace(/\{[^}]+\}/g, (m2) => {
+      path7 = path7.replace(/\{[^}]+\}/g, (m2) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m2];
         i++;
@@ -45306,7 +45748,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path3.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--) {
@@ -45345,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(path3) {
-  return wildcardRegExpCache[path3] ??= new RegExp(
-    path3 === "*" ? "" : `^${path3.replace(
+function buildWildcardRegExp(path7) {
+  return wildcardRegExpCache[path7] ??= new RegExp(
+    path7 === "*" ? "" : `^${path7.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -45369,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, path3, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path7, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path3] = [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(path3, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path7, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path3) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path7) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -45413,12 +45855,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path3) {
+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(path3)) {
+    if (buildWildcardRegExp(k).test(path7)) {
       return [...middleware[k]];
     }
   }
@@ -45432,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, path3, handler) {
+  add(method, path7, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -45447,18 +45889,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path3 === "/*") {
-      path3 = "*";
+    if (path7 === "/*") {
+      path7 = "*";
     }
-    const paramCount = (path3.match(/\/:/g) || []).length;
-    if (/\*$/.test(path3)) {
-      const re = buildWildcardRegExp(path3);
+    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][path3] ||= findMiddleware(middleware[m2], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
+          middleware[m2][path7] ||= findMiddleware(middleware[m2], path7) || findMiddleware(middleware[METHOD_NAME_ALL], path7) || [];
         });
       } else {
-        middleware[method][path3] ||= findMiddleware(middleware[method], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
+        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) {
@@ -45476,7 +45918,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path3) || [path3];
+    const paths = checkOptionalParameter(path7) || [path7];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path23 = paths[i];
       Object.keys(routes).forEach((m2) => {
@@ -45503,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((path3) => [path3, r[method][path3]]) : [];
+      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((path3) => [path3, r[METHOD_NAME_ALL][path3]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path7) => [path7, r[METHOD_NAME_ALL][path7]])
         );
       }
     });
@@ -45536,13 +45978,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path3, handler) {
+  add(method, path7, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path3, handler]);
+    this.#routes.push([method, path7, handler]);
   }
-  match(method, path3) {
+  match(method, path7) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -45557,7 +45999,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path3);
+        res = router.match(method, path7);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -45614,10 +46056,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path3, handler) {
+  insert(method, path7, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path3);
+    const parts = splitRoutingPath(path7);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p2 = parts[i];
@@ -45666,12 +46108,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path3) {
+  search(method, path7) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path3);
+    const parts = splitPath(path7);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -45713,13 +46155,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path3[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 = path3.substring(partOffsets[i]);
+            const restPathString = path7.substring(partOffsets[i]);
             const m2 = matcher.exec(restPathString);
             if (m2) {
               params[name] = m2[0];
@@ -45772,18 +46214,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path3, handler) {
-    const results = checkOptionalParameter(path3);
+  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, path3, handler);
+    this.#node.insert(method, path7, handler);
   }
-  match(method, path3) {
-    return this.#node.search(method, path3);
+  match(method, path7) {
+    return this.#node.search(method, path7);
   }
 };
 
@@ -46713,8 +47155,8 @@ function setAuthCookie(c, name, token, options) {
     sameSite: "Strict"
   });
 }
-function clearAuthCookie(c, name, path3) {
-  deleteCookie(c, name, path3 !== void 0 ? { path: path3 } : void 0);
+function clearAuthCookie(c, name, path7) {
+  deleteCookie(c, name, path7 !== void 0 ? { path: path7 } : void 0);
 }
 function createAuthMiddleware(db) {
   return async (c, next) => {
@@ -47220,11 +47662,11 @@ function isPublished(item) {
   return item["published"] === true;
 }
 function registerPublicContentRoutes(app, registry2, repos, projectors, paths, listRateLimit, resolver) {
-  function registerListRoute(path3, handler) {
+  function registerListRoute(path7, handler) {
     if (listRateLimit) {
-      app.get(path3, listRateLimit, handler);
+      app.get(path7, listRateLimit, handler);
     } else {
-      app.get(path3, handler);
+      app.get(path7, handler);
     }
   }
   registerListRoute(paths.collection("content"), (c) => {
@@ -49189,7 +49631,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 }
 var API_VERSION = (() => {
   try {
-    return "0.4.1";
+    return "0.4.3";
   } catch {
     return "0.0.0";
   }
@@ -49232,6 +49674,9 @@ function registerConfigRoute(app, config3, registry2, db) {
     });
   });
 }
+function liveFields(fields) {
+  return fields.filter((f) => f.removed !== true);
+}
 function registerSchemaRoute(app, registry2, db) {
   app.get("/admin/api/schema", (c) => {
     const content_types = Object.values(registry2.content_types).map((ct2) => ({
@@ -49240,19 +49685,19 @@ function registerSchemaRoute(app, registry2, db) {
       only_one: ct2.only_one,
       ui: ct2.ui,
       system_fields: ct2.system_fields,
-      fields: ct2.fields
+      fields: liveFields(ct2.fields)
     }));
     const taxonomy_types = Object.values(registry2.taxonomy_types).map((tt2) => ({
       name: tt2.name,
       label: tt2.label,
       system_fields: tt2.system_fields,
-      fields: tt2.fields
+      fields: liveFields(tt2.fields)
     }));
     const paragraph_types = Object.values(registry2.paragraph_types).map((pt) => ({
       name: pt.name,
       label: pt.label,
       system_fields: pt.system_fields,
-      fields: pt.fields
+      fields: liveFields(pt.fields)
     }));
     const enum_types = Object.values(registry2.enum_types).map((et2) => ({
       name: et2.name,
@@ -49738,7 +50183,7 @@ function createCmsApp(options) {
     const gqlOptions = options.graphql;
     let gqlHandler = null;
     let initError = null;
-    const ready = import("./handler-7LVYEU5C-ZAJVEGKT.js").then(({ createGraphQLHandler }) => {
+    const ready = import("./handler-45O5OX2C-OIEJ52PN.js").then(({ createGraphQLHandler }) => {
       gqlHandler = createGraphQLHandler(registry2, graphqlRepos, fieldKeyMaps, programmaticResolver, db, gqlOptions);
     }).catch((err) => {
       initError = err;
@@ -49787,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";
@@ -49809,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, "-");
@@ -49833,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 path3 = url2.split("?")[0] ?? "";
-  if (path3.startsWith(apiPrefix)) return true;
-  if (path3.startsWith("/admin/api")) return true;
-  return ABSOLUTE_BACKEND_PATHS.includes(path3);
+  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
@@ -49878,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 extname2 } 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) {
@@ -49887,10 +50332,10 @@ 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(extname2(entry.name))) {
+    } else if (RESOLVER_EXTENSIONS.has(extname3(entry.name))) {
       out.push(full);
     }
   }
@@ -49950,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) {
@@ -49996,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({
@@ -50046,7 +50491,7 @@ async function runDev(options, deps) {
         }
         try {
           const data = await readFile(filePath);
-          const ext = extname3(filePath).slice(1).toLowerCase();
+          const ext = extname4(filePath).slice(1).toLowerCase();
           const mime = UPLOAD_MIME_MAP[ext] ?? "application/octet-stream";
           res.setHeader("Content-Type", mime);
           res.setHeader("X-Content-Type-Options", "nosniff");
@@ -50130,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);
@@ -50198,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);
 }
@@ -50336,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) => {
@@ -50425,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(", ")}`
   );
@@ -50853,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");
@@ -50864,6 +51636,7 @@ registerMigrate(program);
 registerValidate(program);
 registerCreateSuperuser(program);
 registerUsers(program);
+registerVersion(program);
 program.parse();
 /*! Bundled license information: