@nuasite/cli 0.40.0 → 0.42.0

package/dist/index.js

@@ -707,17 +707,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path2) {
-    const ctrl = callVisitor(key, node, visitor, path2);
+  function visit_(key, node, visitor, path) {
+    const ctrl = callVisitor(key, node, visitor, path);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path2, ctrl);
-      return visit_(key, ctrl, visitor, path2);
+      replaceNode(key, path, ctrl);
+      return visit_(key, ctrl, visitor, path);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path2 = Object.freeze(path2.concat(node));
+        path = Object.freeze(path.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path2);
+          const ci = visit_(i, node.items[i], visitor, path);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -728,13 +728,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path2 = Object.freeze(path2.concat(node));
-        const ck = visit_("key", node.key, visitor, path2);
+        path = Object.freeze(path.concat(node));
+        const ck = visit_("key", node.key, visitor, path);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path2);
+        const cv = visit_("value", node.value, visitor, path);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -755,17 +755,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path2) {
-    const ctrl = await callVisitor(key, node, visitor, path2);
+  async function visitAsync_(key, node, visitor, path) {
+    const ctrl = await callVisitor(key, node, visitor, path);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path2, ctrl);
-      return visitAsync_(key, ctrl, visitor, path2);
+      replaceNode(key, path, ctrl);
+      return visitAsync_(key, ctrl, visitor, path);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path2 = Object.freeze(path2.concat(node));
+        path = Object.freeze(path.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path2);
+          const ci = await visitAsync_(i, node.items[i], visitor, path);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -776,13 +776,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path2 = Object.freeze(path2.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path2);
+        path = Object.freeze(path.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path2);
+        const cv = await visitAsync_("value", node.value, visitor, path);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -809,23 +809,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path2) {
+  function callVisitor(key, node, visitor, path) {
     if (typeof visitor === "function")
-      return visitor(key, node, path2);
+      return visitor(key, node, path);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path2);
+      return visitor.Map?.(key, node, path);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path2);
+      return visitor.Seq?.(key, node, path);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path2);
+      return visitor.Pair?.(key, node, path);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path2);
+      return visitor.Scalar?.(key, node, path);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path2);
+      return visitor.Alias?.(key, node, path);
     return;
   }
-  function replaceNode(key, path2, node) {
-    const parent = path2[path2.length - 1];
+  function replaceNode(key, path, node) {
+    const parent = path[path.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1382,10 +1382,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path2, value) {
+  function collectionFromPath(schema, path, value) {
     let v = value;
-    for (let i = path2.length - 1;i >= 0; --i) {
-      const k = path2[i];
+    for (let i = path.length - 1;i >= 0; --i) {
+      const k = path[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1404,7 +1404,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done;
+  var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1425,11 +1425,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path2, value) {
-      if (isEmptyPath(path2))
+    addIn(path, value) {
+      if (isEmptyPath(path))
         this.add(value);
       else {
-        const [key, ...rest] = path2;
+        const [key, ...rest] = path;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1439,8 +1439,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path2) {
-      const [key, ...rest] = path2;
+    deleteIn(path) {
+      const [key, ...rest] = path;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1449,8 +1449,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path2, keepScalar) {
-      const [key, ...rest] = path2;
+    getIn(path, keepScalar) {
+      const [key, ...rest] = path;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1465,15 +1465,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path2) {
-      const [key, ...rest] = path2;
+    hasIn(path) {
+      const [key, ...rest] = path;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path2, value) {
-      const [key, ...rest] = path2;
+    setIn(path, value) {
+      const [key, ...rest] = path;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3863,9 +3863,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path2, value) {
+    addIn(path, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path2, value);
+        this.contents.addIn(path, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -3914,30 +3914,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path2) {
-      if (Collection.isEmptyPath(path2)) {
+    deleteIn(path) {
+      if (Collection.isEmptyPath(path)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path2, keepScalar) {
-      if (Collection.isEmptyPath(path2))
+    getIn(path, keepScalar) {
+      if (Collection.isEmptyPath(path))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path2) {
-      if (Collection.isEmptyPath(path2))
+    hasIn(path) {
+      if (Collection.isEmptyPath(path))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -3946,13 +3946,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path2, value) {
-      if (Collection.isEmptyPath(path2)) {
+    setIn(path, value) {
+      if (Collection.isEmptyPath(path)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path2, value);
+        this.contents.setIn(path, value);
       }
     }
     setSchema(version, options = {}) {
@@ -5846,9 +5846,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path2) => {
+  visit.itemAtPath = (cst, path) => {
     let item = cst;
-    for (const [field, index] of path2) {
+    for (const [field, index] of path) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5857,23 +5857,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path2) => {
-    const parent = visit.itemAtPath(cst, path2.slice(0, -1));
-    const field = path2[path2.length - 1][0];
+  visit.parentCollection = (cst, path) => {
+    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+    const field = path[path.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path2, item, visitor) {
-    let ctrl = visitor(item, path2);
+  function _visit(path, item, visitor) {
+    let ctrl = visitor(item, path);
     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(path2.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5884,10 +5884,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path2);
+          ctrl = ctrl(item, path);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path2) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
   }
   exports.visit = visit;
 });
@@ -7156,14 +7156,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs3 = this.flowScalar(this.type);
+            const fs = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map.items.push({ start, key: fs3, sep: [] });
+              map.items.push({ start, key: fs, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs3);
+              this.stack.push(fs);
             } else {
-              Object.assign(it, { key: fs3, sep: [] });
+              Object.assign(it, { key: fs, sep: [] });
               this.onKeyLine = true;
             }
             return;
@@ -7291,13 +7291,13 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs3 = this.flowScalar(this.type);
+            const fs = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs3, sep: [] });
+              fc.items.push({ start: [], key: fs, sep: [] });
             else if (it.sep)
-              this.stack.push(fs3);
+              this.stack.push(fs);
             else
-              Object.assign(it, { key: fs3, sep: [] });
+              Object.assign(it, { key: fs, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -8524,13 +8524,13 @@ var require_lib = __commonJS((exports) => {
       this.preserveSpace = !!preserveSpace;
     }
   }
-  var types2 = {
+  var types = {
     brace: new TokContext("{"),
     j_oTag: new TokContext("<tag"),
     j_cTag: new TokContext("</tag"),
     j_expr: new TokContext("<tag>...</tag>", true)
   };
-  types2.template = new TokContext("`", true);
+  types.template = new TokContext("`", true);
   var beforeExpr = true;
   var startsExpr = true;
   var isLoop = true;
@@ -9065,17 +9065,17 @@ var require_lib = __commonJS((exports) => {
     context.pop();
   };
   tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
-    context.push(types2.brace);
+    context.push(types.brace);
   };
   tokenTypes[22].updateContext = (context) => {
-    if (context[context.length - 1] === types2.template) {
+    if (context[context.length - 1] === types.template) {
       context.pop();
     } else {
-      context.push(types2.template);
+      context.push(types.template);
     }
   };
   tokenTypes[143].updateContext = (context) => {
-    context.push(types2.j_expr, types2.j_oTag);
+    context.push(types.j_expr, types.j_oTag);
   };
   var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
   var nonASCIIidentifierChars = "\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ADD\u1AE0-\u1AEB\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65";
@@ -9863,7 +9863,7 @@ var require_lib = __commonJS((exports) => {
       return this.finishNode(node, "TypeParameterDeclaration");
     }
     flowInTopLevelContext(cb) {
-      if (this.curContext() !== types2.brace) {
+      if (this.curContext() !== types.brace) {
         const oldContext = this.state.context;
         this.state.context = [oldContext[0]];
         try {
@@ -9898,7 +9898,7 @@ var require_lib = __commonJS((exports) => {
         this.state.noAnonFunctionType = oldNoAnonFunctionType;
       });
       this.state.inType = oldInType;
-      if (!this.state.inType && this.curContext() === types2.brace) {
+      if (!this.state.inType && this.curContext() === types.brace) {
         this.reScan_lt_gt();
       }
       this.expect(48);
@@ -11173,7 +11173,7 @@ var require_lib = __commonJS((exports) => {
           context
         } = this.state;
         const currentContext = context[context.length - 1];
-        if (currentContext === types2.j_oTag || currentContext === types2.j_expr) {
+        if (currentContext === types.j_oTag || currentContext === types.j_expr) {
           context.pop();
         }
       }
@@ -12279,9 +12279,9 @@ var require_lib = __commonJS((exports) => {
       switch (this.state.type) {
         case 5:
           node = this.startNode();
-          this.setContext(types2.brace);
+          this.setContext(types.brace);
           this.next();
-          node = this.jsxParseExpressionContainer(node, types2.j_oTag);
+          node = this.jsxParseExpressionContainer(node, types.j_oTag);
           if (node.expression.type === "JSXEmptyExpression") {
             this.raise(JsxErrors.AttributeIsEmpty, node);
           }
@@ -12300,7 +12300,7 @@ var require_lib = __commonJS((exports) => {
     jsxParseSpreadChild(node) {
       this.next();
       node.expression = this.parseExpression();
-      this.setContext(types2.j_expr);
+      this.setContext(types.j_expr);
       this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXSpreadChild");
@@ -12320,11 +12320,11 @@ var require_lib = __commonJS((exports) => {
     jsxParseAttribute() {
       const node = this.startNode();
       if (this.match(5)) {
-        this.setContext(types2.brace);
+        this.setContext(types.brace);
         this.next();
         this.expect(21);
         node.argument = this.parseMaybeAssignAllowIn();
-        this.setContext(types2.j_oTag);
+        this.setContext(types.j_oTag);
         this.state.canStartJSXElement = true;
         this.expect(8);
         return this.finishNode(node, "JSXSpreadAttribute");
@@ -12383,12 +12383,12 @@ var require_lib = __commonJS((exports) => {
                 break;
               case 5: {
                 const node2 = this.startNode();
-                this.setContext(types2.brace);
+                this.setContext(types.brace);
                 this.next();
                 if (this.match(21)) {
                   children.push(this.jsxParseSpreadChild(node2));
                 } else {
-                  children.push(this.jsxParseExpressionContainer(node2, types2.j_expr));
+                  children.push(this.jsxParseExpressionContainer(node2, types.j_expr));
                 }
                 break;
               }
@@ -12451,11 +12451,11 @@ var require_lib = __commonJS((exports) => {
     }
     getTokenFromCode(code2) {
       const context = this.curContext();
-      if (context === types2.j_expr) {
+      if (context === types.j_expr) {
         this.jsxReadToken();
         return;
       }
-      if (context === types2.j_oTag || context === types2.j_cTag) {
+      if (context === types.j_oTag || context === types.j_cTag) {
         if (isIdentifierStart(code2)) {
           this.jsxReadWord();
           return;
@@ -12465,7 +12465,7 @@ var require_lib = __commonJS((exports) => {
           this.finishToken(144);
           return;
         }
-        if ((code2 === 34 || code2 === 39) && context === types2.j_oTag) {
+        if ((code2 === 34 || code2 === 39) && context === types.j_oTag) {
           this.jsxReadString(code2);
           return;
         }
@@ -12483,17 +12483,17 @@ var require_lib = __commonJS((exports) => {
         type
       } = this.state;
       if (type === 56 && prevType === 143) {
-        context.splice(-2, 2, types2.j_cTag);
+        context.splice(-2, 2, types.j_cTag);
         this.state.canStartJSXElement = false;
       } else if (type === 143) {
-        context.push(types2.j_oTag);
+        context.push(types.j_oTag);
       } else if (type === 144) {
         const out = context[context.length - 1];
-        if (out === types2.j_oTag && prevType === 56 || out === types2.j_cTag) {
+        if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
           context.pop();
-          this.state.canStartJSXElement = context[context.length - 1] === types2.j_expr;
+          this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
         } else {
-          this.setContext(types2.j_expr);
+          this.setContext(types.j_expr);
           this.state.canStartJSXElement = true;
         }
       } else {
@@ -12901,7 +12901,7 @@ var require_lib = __commonJS((exports) => {
       this.end = 0;
       this.lastTokEndLoc = null;
       this.lastTokStartLoc = null;
-      this.context = [types2.brace];
+      this.context = [types.brace];
       this.firstInvalidTemplateEscapePos = null;
       this.strictErrors = new Map;
       this.tokensLength = 0;
@@ -16304,14 +16304,14 @@ var require_lib = __commonJS((exports) => {
     tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
       const node = this.startNode();
       const hasLeadingOperator = this.eat(operator);
-      const types3 = [];
+      const types2 = [];
       do {
-        types3.push(parseConstituentType());
+        types2.push(parseConstituentType());
       } while (this.eat(operator));
-      if (types3.length === 1 && !hasLeadingOperator) {
-        return types3[0];
+      if (types2.length === 1 && !hasLeadingOperator) {
+        return types2[0];
       }
-      node.types = types3;
+      node.types = types2;
       return this.finishNode(node, kind);
     }
     tsParseIntersectionTypeOrHigher() {
@@ -16557,7 +16557,7 @@ var require_lib = __commonJS((exports) => {
       return this.finishNode(node, "TSTypeAliasDeclaration");
     }
     tsInTopLevelContext(cb) {
-      if (this.curContext() !== types2.brace) {
+      if (this.curContext() !== types.brace) {
         const oldContext = this.state.context;
         this.state.context = [oldContext[0]];
         try {
@@ -16878,7 +16878,7 @@ var require_lib = __commonJS((exports) => {
       }));
       if (node.params.length === 0) {
         this.raise(TSErrors.EmptyTypeArguments, node);
-      } else if (!this.state.inType && this.curContext() === types2.brace) {
+      } else if (!this.state.inType && this.curContext() === types.brace) {
         this.reScan_lt_gt();
       }
       this.expect(48);
@@ -17580,7 +17580,7 @@ var require_lib = __commonJS((exports) => {
           context
         } = this.state;
         const currentContext = context[context.length - 1];
-        if (currentContext === types2.j_oTag || currentContext === types2.j_expr) {
+        if (currentContext === types.j_oTag || currentContext === types.j_expr) {
           context.pop();
         }
       }
@@ -22504,15 +22504,28 @@ var init_ast_parser = __esm(() => {
 });
 
 // ../cms/src/content-config-ast.ts
-import fs3 from "fs/promises";
-import path2 from "path";
+import fs from "fs/promises";
+import path from "path";
+function resolveExpression(node, bindings, visited = new Set) {
+  let current = node;
+  while (current.type === "Identifier") {
+    if (visited.has(current.name))
+      return current;
+    visited.add(current.name);
+    const next = bindings.get(current.name);
+    if (!next)
+      return current;
+    current = next;
+  }
+  return current;
+}
 async function parseContentConfig() {
   const projectRoot = getProjectRoot();
   for (const configPath of ["src/content/config.ts", "src/content.config.ts"]) {
-    const fullPath = path2.join(projectRoot, configPath);
+    const fullPath = path.join(projectRoot, configPath);
     let stat;
     try {
-      stat = await fs3.stat(fullPath);
+      stat = await fs.stat(fullPath);
     } catch {
       continue;
     }
@@ -22522,7 +22535,7 @@ async function parseContentConfig() {
         return cached.parsed;
       continue;
     }
-    const content = await fs3.readFile(fullPath, "utf-8");
+    const content = await fs.readFile(fullPath, "utf-8");
     const parsed = parseConfigSource(content, configPath);
     parseCache.set(fullPath, { mtimeMs: stat.mtimeMs, parsed });
     if (parsed.size > 0)
@@ -22535,8 +22548,10 @@ function parseConfigSource(source, sourcePath) {
   const ast = parseFrontmatter(source, sourcePath);
   if (!ast)
     return result;
+  const bindings = new Map;
   const collectionDecls = new Map;
   const exportMap = new Map;
+  const inlineCollections = new Map;
   for (const stmt of ast.program.body) {
     const varDecl = stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : stmt.type === "VariableDeclaration" ? stmt : null;
     if (!varDecl)
@@ -22546,6 +22561,7 @@ function parseConfigSource(source, sourcePath) {
         continue;
       if (!decl.init)
         continue;
+      bindings.set(decl.id.name, decl.init);
       if (decl.id.name === "collections" && decl.init.type === "ObjectExpression") {
         for (const prop of decl.init.properties) {
           if (prop.type !== "ObjectProperty")
@@ -22555,6 +22571,11 @@ function parseConfigSource(source, sourcePath) {
             continue;
           if (prop.value.type === "Identifier") {
             exportMap.set(prop.value.name, key);
+          } else if (prop.value.type === "CallExpression" && isDefineCollectionCallee(prop.value.callee)) {
+            const inlineArg = prop.value.arguments[0];
+            if (inlineArg?.type === "ObjectExpression") {
+              inlineCollections.set(key, inlineArg);
+            }
           }
         }
         continue;
@@ -22567,19 +22588,46 @@ function parseConfigSource(source, sourcePath) {
       }
     }
   }
+  const collectionObjects = new Map(inlineCollections);
   for (const [varName, collectionName] of exportMap) {
     const decl = collectionDecls.get(varName);
-    if (!decl)
-      continue;
+    if (decl)
+      collectionObjects.set(collectionName, decl);
+  }
+  for (const [collectionName, decl] of collectionObjects) {
+    const loaderProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "loader");
+    const loaderOptions = loaderProperty ? extractGlobLoaderOptions(loaderProperty.value, bindings) : {};
+    const loaderPattern = loaderOptions.pattern;
+    const loaderBase = loaderOptions.base;
     const schemaProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "schema");
-    if (!schemaProperty)
+    if (!schemaProperty) {
+      if (!loaderPattern)
+        continue;
+      result.set(collectionName, {
+        name: collectionName,
+        fields: [],
+        loaderPattern,
+        loaderBase
+      });
       continue;
-    const schemaObject = unwrapSchemaToObject(schemaProperty.value);
-    if (!schemaObject)
+    }
+    const schemaObject = unwrapSchemaToObject(schemaProperty.value, bindings);
+    if (!schemaObject) {
+      if (!loaderPattern)
+        continue;
+      result.set(collectionName, {
+        name: collectionName,
+        fields: [],
+        loaderPattern,
+        loaderBase
+      });
       continue;
+    }
     result.set(collectionName, {
       name: collectionName,
-      fields: parseSchemaFields(schemaObject)
+      fields: parseSchemaFields(schemaObject, bindings),
+      loaderPattern,
+      loaderBase
     });
   }
   return result;
@@ -22594,30 +22642,71 @@ function propertyKeyName(key) {
     return key.value;
   return null;
 }
-function unwrapSchemaToObject(node) {
-  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
-    const body = node.body;
+function extractGlobLoaderOptions(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type !== "CallExpression")
+    return {};
+  if (!isGlobCallee(resolved.callee))
+    return {};
+  const arg = resolved.arguments[0];
+  if (!arg)
+    return {};
+  const options = resolveExpression(arg, bindings);
+  if (options.type !== "ObjectExpression")
+    return {};
+  const result = {};
+  for (const prop of options.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    if (key !== "pattern" && key !== "base")
+      continue;
+    const value = extractStaticString(prop.value, bindings);
+    if (value !== undefined)
+      result[key] = value;
+  }
+  return result;
+}
+function extractStaticString(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type === "StringLiteral")
+    return resolved.value;
+  if (resolved.type === "TemplateLiteral" && resolved.expressions.length === 0) {
+    return resolved.quasis[0]?.value.cooked ?? resolved.quasis[0]?.value.raw;
+  }
+  return;
+}
+function isGlobCallee(callee) {
+  return callee.type === "Identifier" && callee.name === "glob";
+}
+function unwrapSchemaToObject(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type === "ArrowFunctionExpression" || resolved.type === "FunctionExpression") {
+    const body = resolved.body;
     if (body.type === "BlockStatement") {
       for (const stmt of body.body) {
         if (stmt.type === "ReturnStatement" && stmt.argument) {
-          return unwrapSchemaToObject(stmt.argument);
+          return unwrapSchemaToObject(stmt.argument, bindings);
         }
       }
       return null;
     }
-    return unwrapSchemaToObject(body);
+    return unwrapSchemaToObject(body, bindings);
   }
-  if (node.type === "CallExpression") {
-    const callee = node.callee;
+  if (resolved.type === "CallExpression") {
+    const callee = resolved.callee;
     if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && (callee.object.name === "z" || callee.object.name === "n") && callee.property.type === "Identifier" && callee.property.name === "object") {
-      const arg = node.arguments[0];
-      if (arg?.type === "ObjectExpression")
-        return arg;
+      const arg = resolved.arguments[0];
+      if (!arg)
+        return null;
+      const resolvedArg = resolveExpression(arg, bindings);
+      if (resolvedArg.type === "ObjectExpression")
+        return resolvedArg;
     }
   }
   return null;
 }
-function parseSchemaFields(schemaObject) {
+function parseSchemaFields(schemaObject, bindings) {
   const fields = [];
   for (const prop of schemaObject.properties) {
     if (prop.type !== "ObjectProperty")
@@ -22626,18 +22715,18 @@ function parseSchemaFields(schemaObject) {
     if (!name)
       continue;
     const field = { name, required: true };
-    analyzeFieldExpression(prop.value, field);
+    analyzeFieldExpression(prop.value, field, bindings);
     fields.push(field);
   }
   return fields;
 }
-function analyzeFieldExpression(node, field) {
-  let current = node;
+function analyzeFieldExpression(node, field, bindings) {
+  let current = resolveExpression(node, bindings);
   while (current) {
     if (current.type !== "CallExpression")
       return;
     if (isBaseCall(current)) {
-      analyzeBaseCall(current, field);
+      analyzeBaseCall(current, field, bindings);
       return;
     }
     if (current.callee.type !== "MemberExpression")
@@ -22651,7 +22740,7 @@ function analyzeFieldExpression(node, field) {
       const direction = arg?.type === "StringLiteral" && arg.value === "desc" ? "desc" : "asc";
       field.orderBy = { direction };
     }
-    current = current.callee.object;
+    current = resolveExpression(current.callee.object, bindings);
   }
 }
 function isBaseCall(node) {
@@ -22664,7 +22753,7 @@ function isBaseCall(node) {
   }
   return false;
 }
-function analyzeBaseCall(node, field) {
+function analyzeBaseCall(node, field, bindings) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
     if (callee.name === "image") {
@@ -22712,14 +22801,36 @@ function analyzeBaseCall(node, field) {
     }
     return;
   }
+  if ((ns === "z" || ns === "n") && fn === "object") {
+    const arg = node.arguments[0];
+    if (!arg)
+      return;
+    const resolved = resolveExpression(arg, bindings);
+    if (resolved.type === "ObjectExpression") {
+      field.type = "object";
+      field.fields = parseSchemaFields(resolved, bindings);
+    }
+    return;
+  }
   if ((ns === "z" || ns === "n") && fn === "array") {
-    const inner = node.arguments[0];
-    if (inner?.type === "CallExpression" && inner.callee.type === "Identifier" && inner.callee.name === "reference") {
+    const innerRaw = node.arguments[0];
+    if (!innerRaw)
+      return;
+    const inner = resolveExpression(innerRaw, bindings);
+    if (inner.type === "CallExpression" && inner.callee.type === "Identifier" && inner.callee.name === "reference") {
       const target = inner.arguments[0];
       if (target?.type === "StringLiteral") {
         field.reference = { target: target.value, isArray: true };
       }
+      return;
     }
+    const innerField = { name: "__item__", required: true };
+    analyzeFieldExpression(inner, innerField, bindings);
+    field.type = "array";
+    if (innerField.type)
+      field.itemType = innerField.type;
+    if (innerField.fields)
+      field.fields = innerField.fields;
     return;
   }
 }
@@ -22752,6 +22863,7 @@ var init_content_config_ast = __esm(() => {
     "text",
     "number",
     "image",
+    "file",
     "url",
     "email",
     "tel",
@@ -22759,6 +22871,8 @@ var init_content_config_ast = __esm(() => {
     "date",
     "datetime",
     "time",
+    "year",
+    "month",
     "textarea"
   ]);
   VALID_HINT_KEYS = new Set([
@@ -22784,8 +22898,8 @@ function slugifyHref(text) {
 }
 
 // ../cms/src/collection-scanner.ts
-import fs4 from "fs/promises";
-import path3 from "path";
+import fs2 from "fs/promises";
+import path2 from "path";
 function normalizeFieldName(name) {
   return name.toLowerCase().replace(/[_-]/g, "");
 }
@@ -22886,7 +23000,9 @@ function inferFieldType(value, key) {
   }
   return "text";
 }
-function mergeFieldObservations(observations) {
+function mergeFieldObservations(observations, depth = 0) {
+  if (depth >= MAX_NESTED_FIELD_DEPTH)
+    return [];
   const fields = [];
   for (const obs of observations) {
     const nonNullValues = obs.values.filter((v2) => v2 !== null && v2 !== undefined);
@@ -22937,11 +23053,21 @@ function mergeFieldObservations(observations) {
             for (const item of objectItems) {
               collectFieldObservations(subFieldMap, item, objectItems.length);
             }
-            field.fields = mergeFieldObservations(Array.from(subFieldMap.values()));
+            field.fields = mergeFieldObservations(Array.from(subFieldMap.values()), depth + 1);
           }
         }
       }
     }
+    if (fieldType === "object") {
+      const objectValues = nonNullValues.filter((v2) => typeof v2 === "object" && v2 !== null && !Array.isArray(v2));
+      if (objectValues.length > 0) {
+        const subFieldMap = new Map;
+        for (const item of objectValues) {
+          collectFieldObservations(subFieldMap, item, objectValues.length);
+        }
+        field.fields = mergeFieldObservations(Array.from(subFieldMap.values()), depth + 1);
+      }
+    }
     fields.push(field);
   }
   return fields;
@@ -22957,7 +23083,7 @@ function collectFieldObservations(fieldMap, data, totalEntries) {
     obs.presentCount++;
   }
 }
-function buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, entryCount, extra) {
+function assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, entryCount, extra) {
   for (const obs of fieldMap.values()) {
     obs.totalEntries = entryCount;
   }
@@ -22967,7 +23093,7 @@ function buildCollectionDefinition(collectionName, contentDir, fieldMap, entryIn
   return {
     name: collectionName,
     label,
-    path: path3.join(contentDir, collectionName),
+    path: path2.join(contentDir, collectionName),
     entryCount,
     fields,
     fileExtension: "md",
@@ -22975,9 +23101,71 @@ function buildCollectionDefinition(collectionName, contentDir, fieldMap, entryIn
     ...extra
   };
 }
+function getCollectionSourceBasePath(basePath, collectionName, contentDir) {
+  const projectRoot = getProjectRoot();
+  const defaultContentDir = path2.isAbsolute(contentDir) ? contentDir : path2.join(projectRoot, contentDir);
+  const defaultCollectionPath = path2.join(defaultContentDir, collectionName);
+  if (path2.resolve(basePath) === path2.resolve(defaultCollectionPath)) {
+    return path2.join(contentDir, collectionName);
+  }
+  const relativeBase = path2.relative(projectRoot, basePath);
+  if (relativeBase && !relativeBase.startsWith("..") && !path2.isAbsolute(relativeBase)) {
+    return relativeBase;
+  }
+  return basePath;
+}
+async function buildCollectionDefinition(basePath, sources, collectionName, contentDir) {
+  if (sources.length === 0)
+    return null;
+  const sourceBasePath = getCollectionSourceBasePath(basePath, collectionName, contentDir);
+  const hasMd = sources.some((s) => s.relPath.endsWith(".md"));
+  const fileExtension = hasMd ? "md" : "mdx";
+  const fieldMap = new Map;
+  const allDirectives = {};
+  const entryInfos = [];
+  let hasDraft = false;
+  const fileContents = await Promise.all(sources.map((s) => fs2.readFile(path2.join(basePath, s.relPath), "utf-8")));
+  for (let i = 0;i < sources.length; i++) {
+    const source = sources[i];
+    const content = fileContents[i];
+    const frontmatter = parseFrontmatter2(content);
+    const directives = parseFieldDirectives(content);
+    for (const [key, value] of Object.entries(directives)) {
+      if (!allDirectives[key]) {
+        allDirectives[key] = value;
+      }
+    }
+    const entryInfo = {
+      slug: source.slug,
+      sourcePath: path2.join(sourceBasePath, source.relPath)
+    };
+    if (frontmatter) {
+      if (typeof frontmatter.title === "string") {
+        entryInfo.title = frontmatter.title;
+      }
+      if (typeof frontmatter.draft === "boolean" && frontmatter.draft) {
+        entryInfo.draft = true;
+      }
+      entryInfo.data = frontmatter;
+    }
+    entryInfos.push(entryInfo);
+    if (!frontmatter)
+      continue;
+    if (frontmatter.draft === true)
+      hasDraft = true;
+    collectFieldObservations(fieldMap, frontmatter, sources.length);
+  }
+  const def = assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+    path: sourceBasePath,
+    supportsDraft: hasDraft,
+    fileExtension
+  });
+  assignFieldMetadata(def.fields, allDirectives);
+  return def;
+}
 async function scanCollection(collectionPath, collectionName, contentDir) {
   try {
-    const dirEntries = await fs4.readdir(collectionPath, { withFileTypes: true });
+    const dirEntries = await fs2.readdir(collectionPath, { withFileTypes: true });
     const sources = [];
     const takenSlugs = new Set;
     for (const entry of dirEntries) {
@@ -22994,9 +23182,9 @@ async function scanCollection(collectionPath, collectionName, contentDir) {
       if (takenSlugs.has(dir.name))
         return null;
       for (const ext of ["md", "mdx"]) {
-        const relPath = path3.join(dir.name, `index.${ext}`);
+        const relPath = path2.join(dir.name, `index.${ext}`);
         try {
-          await fs4.access(path3.join(collectionPath, relPath));
+          await fs2.access(path2.join(collectionPath, relPath));
           return { slug: dir.name, relPath };
         } catch {}
       }
@@ -23008,49 +23196,71 @@ async function scanCollection(collectionPath, collectionName, contentDir) {
     }
     if (sources.length === 0)
       return null;
-    const hasMd = sources.some((s) => s.relPath.endsWith(".md"));
-    const fileExtension = hasMd ? "md" : "mdx";
-    const fieldMap = new Map;
-    const allDirectives = {};
-    const entryInfos = [];
-    let hasDraft = false;
-    const fileContents = await Promise.all(sources.map((s) => fs4.readFile(path3.join(collectionPath, s.relPath), "utf-8")));
-    for (let i = 0;i < sources.length; i++) {
-      const source = sources[i];
-      const content = fileContents[i];
-      const frontmatter = parseFrontmatter2(content);
-      const directives = parseFieldDirectives(content);
-      for (const [key, value] of Object.entries(directives)) {
-        if (!allDirectives[key]) {
-          allDirectives[key] = value;
-        }
+    return await buildCollectionDefinition(collectionPath, sources, collectionName, contentDir);
+  } catch {
+    return null;
+  }
+}
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/")
+          i++;
+      } else {
+        re += "[^/]*";
       }
-      const entryInfo = {
-        slug: source.slug,
-        sourcePath: path3.join(contentDir, collectionName, source.relPath)
-      };
-      if (frontmatter) {
-        if (typeof frontmatter.title === "string") {
-          entryInfo.title = frontmatter.title;
-        }
-        if (typeof frontmatter.draft === "boolean" && frontmatter.draft) {
-          entryInfo.draft = true;
-        }
-        entryInfo.data = frontmatter;
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      if (end === -1) {
+        re += "\\{";
+      } else {
+        const opts = glob.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&"));
+        re += `(?:${opts.join("|")})`;
+        i = end;
       }
-      entryInfos.push(entryInfo);
-      if (!frontmatter)
-        continue;
-      if (frontmatter.draft === true)
-        hasDraft = true;
-      collectFieldObservations(fieldMap, frontmatter, sources.length);
+    } else if (".+^$()|[]\\".includes(c)) {
+      re += `\\${c}`;
+    } else {
+      re += c;
     }
-    const def = buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
-      supportsDraft: hasDraft,
-      fileExtension
-    });
-    assignFieldMetadata(def.fields, allDirectives);
-    return def;
+  }
+  return new RegExp(`^${re}$`);
+}
+async function walkFiles(dir, prefix = "") {
+  let dirEntries;
+  try {
+    dirEntries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of dirEntries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith("."))
+      continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      out.push(...await walkFiles(path2.join(dir, entry.name), rel));
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+async function scanGlobCollection(collectionName, baseRel, pattern, contentDir) {
+  try {
+    const absBase = path2.join(getProjectRoot(), baseRel);
+    const matcher = globToRegExp(pattern);
+    const sources = (await walkFiles(absBase)).filter((rel) => (rel.endsWith(".md") || rel.endsWith(".mdx")) && matcher.test(rel)).map((rel) => ({ slug: rel.replace(/\.(md|mdx)$/, ""), relPath: rel }));
+    if (sources.length === 0)
+      return null;
+    return await buildCollectionDefinition(absBase, sources, collectionName, contentDir);
   } catch {
     return null;
   }
@@ -23069,19 +23279,53 @@ function applyParsedConfig(collections, parsed) {
       const field = fieldsByName.get(pf.name);
       if (!field)
         continue;
-      if (pf.type) {
-        field.type = pf.type;
-        if (pf.options)
-          field.options = pf.options;
-      }
-      if (pf.hints)
-        field.hints = pf.hints;
-      if (pf.astroImage)
-        field.astroImage = true;
-      field.required = pf.required;
+      applyParsedFieldOverrides(field, pf);
     }
   }
 }
+function applyParsedFieldOverrides(field, pf) {
+  if (pf.type) {
+    field.type = pf.type;
+    if (pf.options)
+      field.options = pf.options;
+  }
+  if (pf.itemType)
+    field.itemType = pf.itemType;
+  if (pf.hints)
+    field.hints = pf.hints;
+  if (pf.astroImage)
+    field.astroImage = true;
+  field.required = pf.required;
+  if (pf.fields) {
+    const existingByName = new Map((field.fields ?? []).map((f) => [f.name, f]));
+    field.fields = pf.fields.map((subPf) => {
+      const existing = existingByName.get(subPf.name);
+      if (existing) {
+        applyParsedFieldOverrides(existing, subPf);
+        return existing;
+      }
+      return parsedFieldToFieldDefinition(subPf);
+    });
+  }
+}
+function parsedFieldToFieldDefinition(pf) {
+  const fd = {
+    name: pf.name,
+    type: pf.type ?? (pf.fields ? "object" : "text"),
+    required: pf.required
+  };
+  if (pf.options)
+    fd.options = pf.options;
+  if (pf.itemType)
+    fd.itemType = pf.itemType;
+  if (pf.hints)
+    fd.hints = pf.hints;
+  if (pf.astroImage)
+    fd.astroImage = true;
+  if (pf.fields)
+    fd.fields = pf.fields.map(parsedFieldToFieldDefinition);
+  return fd;
+}
 function applyCollectionOrderBy(collections, parsed) {
   for (const [collectionName, parsedColl] of parsed) {
     const orderField = parsedColl.fields.find((f) => f.orderBy);
@@ -23275,7 +23519,7 @@ function detectDerivedHrefFields(collections) {
 }
 async function scanDataCollection(collectionPath, collectionName, contentDir) {
   try {
-    const dirEntries = await fs4.readdir(collectionPath, { withFileTypes: true });
+    const dirEntries = await fs2.readdir(collectionPath, { withFileTypes: true });
     const sources = [];
     const takenSlugs = new Set;
     for (const entry of dirEntries) {
@@ -23292,9 +23536,9 @@ async function scanDataCollection(collectionPath, collectionName, contentDir) {
       if (takenSlugs.has(dir.name))
         return null;
       for (const indexExt of ["json", "yaml", "yml"]) {
-        const relPath = path3.join(dir.name, `index.${indexExt}`);
+        const relPath = path2.join(dir.name, `index.${indexExt}`);
         try {
-          await fs4.access(path3.join(collectionPath, relPath));
+          await fs2.access(path2.join(collectionPath, relPath));
           return { slug: dir.name, relPath };
         } catch {}
       }
@@ -23309,7 +23553,7 @@ async function scanDataCollection(collectionPath, collectionName, contentDir) {
     const fieldMap = new Map;
     const entryInfos = [];
     const ext = sources.some((s) => s.relPath.endsWith(".json")) ? "json" : sources.some((s) => s.relPath.endsWith(".yaml")) ? "yaml" : "yml";
-    const fileContents = await Promise.all(sources.map((s) => fs4.readFile(path3.join(collectionPath, s.relPath), "utf-8").catch(() => null)));
+    const fileContents = await Promise.all(sources.map((s) => fs2.readFile(path2.join(collectionPath, s.relPath), "utf-8").catch(() => null)));
     for (let i = 0;i < sources.length; i++) {
       const source = sources[i];
       const raw = fileContents[i];
@@ -23327,12 +23571,12 @@ async function scanDataCollection(collectionPath, collectionName, contentDir) {
       entryInfos.push({
         slug: source.slug,
         title,
-        sourcePath: path3.join(contentDir, collectionName, source.relPath),
+        sourcePath: path2.join(contentDir, collectionName, source.relPath),
         data
       });
       collectFieldObservations(fieldMap, data, sources.length);
     }
-    return buildCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+    return assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
       type: "data",
       fileExtension: ext
     });
@@ -23342,12 +23586,12 @@ async function scanDataCollection(collectionPath, collectionName, contentDir) {
 }
 async function scanCollections(contentDir = "src/content") {
   const projectRoot = getProjectRoot();
-  const fullContentDir = path3.isAbsolute(contentDir) ? contentDir : path3.join(projectRoot, contentDir);
+  const fullContentDir = path2.isAbsolute(contentDir) ? contentDir : path2.join(projectRoot, contentDir);
   const collections = {};
   try {
-    const entries = await fs4.readdir(fullContentDir, { withFileTypes: true });
+    const entries = await fs2.readdir(fullContentDir, { withFileTypes: true });
     const scanPromises = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && !entry.name.startsWith(".")).map(async (entry) => {
-      const collectionPath = path3.join(fullContentDir, entry.name);
+      const collectionPath = path2.join(fullContentDir, entry.name);
       const definition = await scanCollection(collectionPath, entry.name, contentDir) ?? await scanDataCollection(collectionPath, entry.name, contentDir);
       if (definition) {
         collections[entry.name] = definition;
@@ -23356,6 +23600,20 @@ async function scanCollections(contentDir = "src/content") {
     await Promise.all(scanPromises);
   } catch {}
   const parsed = await parseContentConfig();
+  for (const [collectionName, parsedCollection] of parsed) {
+    if (collections[collectionName])
+      continue;
+    if (!parsedCollection.loaderBase || !parsedCollection.loaderPattern)
+      continue;
+    const definition = await scanGlobCollection(collectionName, parsedCollection.loaderBase, parsedCollection.loaderPattern, contentDir);
+    if (!definition)
+      continue;
+    const baseName = parsedCollection.loaderBase.replace(/[/\\]+$/, "").split(/[/\\]/).pop();
+    if (baseName && baseName !== collectionName && collections[baseName]) {
+      definition.parentCollection = baseName;
+    }
+    collections[collectionName] = definition;
+  }
   applyParsedConfig(collections, parsed);
   detectReferenceFields(collections, parsed);
   detectDerivedHrefFields(collections);
@@ -23363,7 +23621,7 @@ async function scanCollections(contentDir = "src/content") {
   applyCollectionOrderBy(collections, parsed);
   return collections;
 }
-var import_yaml, DATE_PATTERN, URL_PATTERN, IMAGE_EXTENSIONS, MAX_SELECT_OPTIONS = 10, TEXTAREA_MIN_LENGTH = 200, SIDEBAR_FIELD_NAMES, DIRECTIVE_PATTERN, FREE_TEXT_FIELD_NAMES, PUBLISH_TOGGLE_NAMES, PUBLISH_DATE_NAMES, FRONTMATTER_PATTERN, HREF_SUFFIXES;
+var import_yaml, DATE_PATTERN, URL_PATTERN, IMAGE_EXTENSIONS, MAX_SELECT_OPTIONS = 10, TEXTAREA_MIN_LENGTH = 200, SIDEBAR_FIELD_NAMES, DIRECTIVE_PATTERN, FREE_TEXT_FIELD_NAMES, PUBLISH_TOGGLE_NAMES, PUBLISH_DATE_NAMES, FRONTMATTER_PATTERN, MAX_NESTED_FIELD_DEPTH = 16, HREF_SUFFIXES;
 var init_collection_scanner = __esm(() => {
   init_config();
   init_content_config_ast();
@@ -23413,8 +23671,8 @@ var init_collection_scanner = __esm(() => {
 });
 
 // ../cms/src/component-registry.ts
-import fs5 from "fs/promises";
-import path4 from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 
 class ComponentRegistry {
   components = new Map;
@@ -23424,7 +23682,7 @@ class ComponentRegistry {
   }
   async scan() {
     for (const dir of this.componentDirs) {
-      const fullPath = path4.join(getProjectRoot(), dir);
+      const fullPath = path3.join(getProjectRoot(), dir);
       try {
         await this.scanDirectory(fullPath, dir);
       } catch {}
@@ -23437,10 +23695,10 @@ class ComponentRegistry {
     return this.components.get(name);
   }
   async scanDirectory(dir, relativePath) {
-    const entries = await fs5.readdir(dir, { withFileTypes: true });
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4.join(dir, entry.name);
-      const relPath = path4.join(relativePath, entry.name);
+      const fullPath = path3.join(dir, entry.name);
+      const relPath = path3.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         await this.scanDirectory(fullPath, relPath);
       } else if (entry.isFile() && entry.name.endsWith(".astro")) {
@@ -23450,8 +23708,8 @@ class ComponentRegistry {
   }
   async parseComponent(filePath, relativePath) {
     try {
-      const content = await fs5.readFile(filePath, "utf-8");
-      const componentName = path4.basename(filePath, ".astro");
+      const content = await fs3.readFile(filePath, "utf-8");
+      const componentName = path3.basename(filePath, ".astro");
       const props = await this.extractProps(content);
       const slots = this.extractSlots(content);
       const description = this.extractDescription(content);
@@ -23710,14 +23968,14 @@ var init_local = __esm(() => {
 });
 
 // ../cms/src/media/project-images.ts
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 async function listProjectImages(options) {
   const root = getProjectRoot();
-  const excludeDir = options?.excludeDir ? path5.resolve(options.excludeDir) : null;
+  const excludeDir = options?.excludeDir ? path4.resolve(options.excludeDir) : null;
   const scanDirs = [
-    { dir: path5.join(root, "public"), urlPrefix: "" },
-    { dir: path5.join(root, "src"), urlPrefix: null }
+    { dir: path4.join(root, "public"), urlPrefix: "" },
+    { dir: path4.join(root, "src"), urlPrefix: null }
   ];
   const results = await Promise.all(scanDirs.map(({ dir, urlPrefix }) => {
     const items2 = [];
@@ -23728,11 +23986,11 @@ async function listProjectImages(options) {
   return items;
 }
 async function scanDirectory(currentDir, baseDir, urlPrefix, excludeDir, items) {
-  if (excludeDir && path5.resolve(currentDir) === excludeDir)
+  if (excludeDir && path4.resolve(currentDir) === excludeDir)
     return;
   let entries;
   try {
-    entries = await fs6.readdir(currentDir, { withFileTypes: true });
+    entries = await fs4.readdir(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -23741,15 +23999,15 @@ async function scanDirectory(currentDir, baseDir, urlPrefix, excludeDir, items)
     const name = String(entry.name);
     if (name.startsWith(".") || name === "node_modules")
       continue;
-    const fullPath = path5.join(currentDir, name);
+    const fullPath = path4.join(currentDir, name);
     if (entry.isDirectory()) {
       subdirs.push(scanDirectory(fullPath, baseDir, urlPrefix, excludeDir, items));
     } else if (entry.isFile()) {
-      const ext = path5.extname(name).toLowerCase();
+      const ext = path4.extname(name).toLowerCase();
       if (!IMAGE_EXTENSIONS2.has(ext))
         continue;
-      const relativePath = path5.relative(baseDir, fullPath).split(path5.sep).join("/");
-      const url = urlPrefix !== null ? `/${relativePath}` : `/${path5.relative(getProjectRoot(), fullPath).split(path5.sep).join("/")}`;
+      const relativePath = path4.relative(baseDir, fullPath).split(path4.sep).join("/");
+      const url = urlPrefix !== null ? `/${relativePath}` : `/${path4.relative(getProjectRoot(), fullPath).split(path4.sep).join("/")}`;
       items.push({
         id: `project:${url}`,
         url,
@@ -23769,7 +24027,7 @@ var init_project_images = __esm(() => {
 
 // ../cms/src/utils.ts
 import { createHash } from "crypto";
-import path6 from "path";
+import path5 from "path";
 function normalizePagePath(url) {
   let pathname;
   try {
@@ -23822,21 +24080,21 @@ function escapeReplacement(str) {
   return str.replace(/\$/g, "$$$$");
 }
 function resolveSourcePath(sourcePath) {
-  return path6.isAbsolute(sourcePath) ? sourcePath : path6.join(getProjectRoot(), sourcePath);
+  return path5.isAbsolute(sourcePath) ? sourcePath : path5.join(getProjectRoot(), sourcePath);
 }
 function resolveAndValidatePath(filePath) {
   const projectRoot = getProjectRoot();
-  const resolvedRoot = path6.resolve(projectRoot);
+  const resolvedRoot = path5.resolve(projectRoot);
   const isAbsoluteFs = filePath.startsWith(resolvedRoot);
   const normalizedPath = !isAbsoluteFs && filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path6.isAbsolute(normalizedPath) ? path6.resolve(normalizedPath) : path6.resolve(projectRoot, normalizedPath);
-  if (!fullPath.startsWith(resolvedRoot + path6.sep) && fullPath !== resolvedRoot) {
+  const fullPath = path5.isAbsolute(normalizedPath) ? path5.resolve(normalizedPath) : path5.resolve(projectRoot, normalizedPath);
+  if (!fullPath.startsWith(resolvedRoot + path5.sep) && fullPath !== resolvedRoot) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
   return fullPath;
 }
 async function acquireFileLock(filePath) {
-  const key = path6.resolve(filePath);
+  const key = path5.resolve(filePath);
   while (fileLocks.has(key)) {
     await fileLocks.get(key);
   }
@@ -23857,8 +24115,8 @@ function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function relativeImportPath(fromFile, toFile) {
-  const fromDir = path6.dirname(fromFile);
-  let rel = path6.relative(fromDir, toFile).split(path6.sep).join("/");
+  const fromDir = path5.dirname(fromFile);
+  let rel = path5.relative(fromDir, toFile).split(path5.sep).join("/");
   if (!rel.startsWith("."))
     rel = `./${rel}`;
   return rel;
@@ -23870,8 +24128,8 @@ var init_utils2 = __esm(() => {
 });
 
 // ../cms/src/handlers/component-ops.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 async function handleInsertComponent(request, manifestWriter) {
   const { position, referenceComponentId, componentName, props, meta } = request;
   if (!meta?.url) {
@@ -23904,7 +24162,7 @@ async function handleInsertComponent(request, manifestWriter) {
     try {
       let currentContent;
       try {
-        currentContent = await fs7.readFile(fullPath, "utf-8");
+        currentContent = await fs5.readFile(fullPath, "utf-8");
       } catch {
         return { success: false, error: `Source file not found: ${filePath}` };
       }
@@ -23929,7 +24187,7 @@ async function handleInsertComponent(request, manifestWriter) {
 `);
       lines.splice(insertIndex, 0, indentedJsx);
       ensureComponentImport(lines, componentName, componentDef.file, filePath);
-      await fs7.writeFile(fullPath, lines.join(`
+      await fs5.writeFile(fullPath, lines.join(`
 `), "utf-8");
       return {
         success: true,
@@ -23972,7 +24230,7 @@ async function handleRemoveComponent(request, manifestWriter) {
     try {
       let currentContent;
       try {
-        currentContent = await fs7.readFile(fullPath, "utf-8");
+        currentContent = await fs5.readFile(fullPath, "utf-8");
       } catch {
         return { success: false, error: `Source file not found: ${filePath}` };
       }
@@ -23994,7 +24252,7 @@ async function handleRemoveComponent(request, manifestWriter) {
         removeCount++;
       }
       lines.splice(startLine, removeCount);
-      await fs7.writeFile(fullPath, lines.join(`
+      await fs5.writeFile(fullPath, lines.join(`
 `), "utf-8");
       return {
         success: true,
@@ -24089,9 +24347,9 @@ function getComponentOccurrenceIndex(manifest, referenceComponent) {
 async function findComponentInvocationFile(projectRoot, pageUrl, manifest, referenceComponent) {
   if (referenceComponent.invocationSourcePath) {
     const filePath = normalizeFilePath(referenceComponent.invocationSourcePath);
-    const fullPath = path7.resolve(projectRoot, filePath);
+    const fullPath = path6.resolve(projectRoot, filePath);
     try {
-      const content = await fs7.readFile(fullPath, "utf-8");
+      const content = await fs5.readFile(fullPath, "utf-8");
       const lines = content.split(`
 `);
       const lineIndex = findComponentInvocationLine(lines, referenceComponent.componentName, referenceComponent.invocationIndex ?? 0);
@@ -24103,9 +24361,9 @@ async function findComponentInvocationFile(projectRoot, pageUrl, manifest, refer
   const candidates = getPageFileCandidates(pageUrl);
   const occurrenceIndex = getComponentOccurrenceIndex(manifest, referenceComponent);
   for (const candidate of candidates) {
-    const fullPath = path7.resolve(projectRoot, candidate);
+    const fullPath = path6.resolve(projectRoot, candidate);
     try {
-      const content = await fs7.readFile(fullPath, "utf-8");
+      const content = await fs5.readFile(fullPath, "utf-8");
       const lines = content.split(`
 `);
       const lineIndex = findComponentInvocationLine(lines, referenceComponent.componentName, occurrenceIndex);
@@ -24163,7 +24421,7 @@ function getIndentation(line) {
 function normalizeFilePath(p) {
   if (!p.startsWith("/"))
     return p;
-  const projectRoot = path7.resolve(getProjectRoot());
+  const projectRoot = path6.resolve(getProjectRoot());
   if (p.startsWith(projectRoot))
     return p;
   return p.slice(1);
@@ -24195,7 +24453,7 @@ var init_component_ops = __esm(() => {
 });
 
 // ../cms/src/handlers/array-ops.ts
-import fs8 from "fs/promises";
+import fs6 from "fs/promises";
 function parseInlineArrayName(componentName) {
   if (!componentName.startsWith("__array:"))
     return null;
@@ -24275,7 +24533,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
     const { arrayVarName, mapOccurrence } = parsed;
     const filePath2 = normalizeFilePath(component.invocationSourcePath ?? component.sourcePath);
     const fullPath2 = resolveAndValidatePath(filePath2);
-    const content2 = await fs8.readFile(fullPath2, "utf-8");
+    const content2 = await fs6.readFile(fullPath2, "utf-8");
     const lines2 = content2.split(`
 `);
     const fmEnd2 = findFrontmatterEnd(lines2);
@@ -24320,7 +24578,7 @@ async function resolveArrayContext(component, manifest, pageUrl) {
   const invocation = await findComponentInvocationFile(projectRoot, pageUrl, manifest, component);
   const filePath = invocation?.filePath ?? normalizeFilePath(component.invocationSourcePath ?? component.sourcePath);
   const fullPath = resolveAndValidatePath(filePath);
-  const content = await fs8.readFile(fullPath, "utf-8");
+  const content = await fs6.readFile(fullPath, "utf-8");
   const lines = content.split(`
 `);
   let refLineIndex;
@@ -24392,7 +24650,7 @@ async function handleRemoveArrayItem(request, manifestWriter) {
     const { fullPath, arrayIndex } = ctx;
     const release = await acquireFileLock(fullPath);
     try {
-      const freshContent = await fs8.readFile(fullPath, "utf-8");
+      const freshContent = await fs6.readFile(fullPath, "utf-8");
       const freshLines = freshContent.split(`
 `);
       const freshFmEnd = findFrontmatterEnd(freshLines);
@@ -24421,7 +24679,7 @@ async function handleRemoveArrayItem(request, manifestWriter) {
           freshLines[removeStart - 1] = prevLine.replace(/,\s*$/, "");
         }
       }
-      await fs8.writeFile(fullPath, freshLines.join(`
+      await fs6.writeFile(fullPath, freshLines.join(`
 `), "utf-8");
       return {
         success: true,
@@ -24463,7 +24721,7 @@ async function handleAddArrayItem(request, manifestWriter) {
     const { fullPath, arrayIndex } = ctx;
     const release = await acquireFileLock(fullPath);
     try {
-      const freshContent = await fs8.readFile(fullPath, "utf-8");
+      const freshContent = await fs6.readFile(fullPath, "utf-8");
       const freshLines = freshContent.split(`
 `);
       const freshFmEnd = findFrontmatterEnd(freshLines);
@@ -24514,7 +24772,7 @@ async function handleAddArrayItem(request, manifestWriter) {
           break;
         }
       }
-      await fs8.writeFile(fullPath, freshLines.join(`
+      await fs6.writeFile(fullPath, freshLines.join(`
 `), "utf-8");
       return {
         success: true,
@@ -24570,46 +24828,46 @@ var init_array_ops = __esm(() => {
 
 // ../cms/src/astro-image-paths.ts
 import { createHash as createHash2 } from "crypto";
-import fs9 from "fs/promises";
-import path8 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 function isHugoStyleEntry(entryAbsPath) {
-  return HUGO_INDEX_RE.test(path8.basename(entryAbsPath));
+  return HUGO_INDEX_RE.test(path7.basename(entryAbsPath));
 }
 function shortContentHash(buf) {
   return createHash2("sha256").update(buf).digest("hex").slice(0, 8);
 }
 async function pickAstroImageTarget(args) {
-  const entryDir = path8.dirname(args.entryAbsPath);
+  const entryDir = path7.dirname(args.entryAbsPath);
   const isHugoStyle = isHugoStyleEntry(args.entryAbsPath);
-  const safeFilename = path8.basename(args.originalFilename);
+  const safeFilename = path7.basename(args.originalFilename);
   if (!safeFilename || safeFilename === "." || safeFilename === "..") {
     throw new Error(`Invalid filename: ${args.originalFilename}`);
   }
   const baseName = isHugoStyle ? safeFilename : `${args.slug}-${safeFilename}`;
-  const baseAbs = path8.join(entryDir, baseName);
+  const baseAbs = path7.join(entryDir, baseName);
   if (await isFreeOrMatching(baseAbs, args.compareBuffer)) {
     return { absPath: baseAbs, relPath: `./${baseName}` };
   }
   const candidateAbs = await pickHashedSibling(entryDir, baseName, args.compareBuffer);
-  return { absPath: candidateAbs, relPath: `./${path8.basename(candidateAbs)}` };
+  return { absPath: candidateAbs, relPath: `./${path7.basename(candidateAbs)}` };
 }
 async function pickSiblingTarget(dir, filename, buf) {
-  const safe = path8.basename(filename);
+  const safe = path7.basename(filename);
   if (!safe || safe === "." || safe === "..") {
     throw new Error(`Invalid filename: ${filename}`);
   }
-  const baseAbs = path8.join(dir, safe);
+  const baseAbs = path7.join(dir, safe);
   if (await isFreeOrMatching(baseAbs, buf))
     return baseAbs;
   return pickHashedSibling(dir, safe, buf);
 }
 async function pickHashedSibling(dir, baseName, buf) {
   const hash = shortContentHash(buf);
-  const ext = path8.extname(baseName);
-  const stem = path8.basename(baseName, ext);
+  const ext = path7.extname(baseName);
+  const stem = path7.basename(baseName, ext);
   for (let attempt = 0;attempt < 5; attempt++) {
     const suffix = attempt === 0 ? hash : `${hash}-${attempt}`;
-    const candidateAbs = path8.join(dir, `${stem}-${suffix}${ext}`);
+    const candidateAbs = path7.join(dir, `${stem}-${suffix}${ext}`);
     if (await isFreeOrMatching(candidateAbs, buf))
       return candidateAbs;
   }
@@ -24617,10 +24875,10 @@ async function pickHashedSibling(dir, baseName, buf) {
 }
 async function isFreeOrMatching(absPath, compareBuffer) {
   try {
-    const stat = await fs9.stat(absPath);
+    const stat = await fs7.stat(absPath);
     if (stat.size !== compareBuffer.length)
       return false;
-    const existing = await fs9.readFile(absPath);
+    const existing = await fs7.readFile(absPath);
     return compareBuffer.equals(existing);
   } catch {
     return true;
@@ -24632,8 +24890,8 @@ var init_astro_image_paths = __esm(() => {
 });
 
 // ../cms/src/handlers/astro-image-upload.ts
-import fs10 from "fs/promises";
-import path9 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 async function tryAstroImageUpload(args) {
   const { collection, entry, field } = args.context;
   if (!collection || !entry || !field)
@@ -24655,12 +24913,12 @@ async function tryAstroImageUpload(args) {
     originalFilename: args.originalFilename,
     compareBuffer: args.fileBuffer
   });
-  await fs10.mkdir(path9.dirname(target.absPath), { recursive: true });
-  await fs10.writeFile(target.absPath, args.fileBuffer);
+  await fs8.mkdir(path8.dirname(target.absPath), { recursive: true });
+  await fs8.writeFile(target.absPath, args.fileBuffer);
   return {
     success: true,
     url: target.relPath,
-    filename: path9.basename(target.absPath)
+    filename: path8.basename(target.absPath)
   };
 }
 var init_astro_image_upload = __esm(() => {
@@ -24669,12 +24927,12 @@ var init_astro_image_upload = __esm(() => {
 });
 
 // ../cms/src/handlers/markdown-ops.ts
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 async function handleGetMarkdownContent(filePath) {
   try {
     const fullPath = resolveAndValidatePath(filePath);
-    const raw = await fs11.readFile(fullPath, "utf-8");
+    const raw = await fs9.readFile(fullPath, "utf-8");
     if (isDataFile(filePath)) {
       const data = filePath.endsWith(".json") ? JSON.parse(raw) : import_yaml2.default.parse(raw);
       return {
@@ -24699,14 +24957,14 @@ async function handleUpdateMarkdown(request, componentDefinitions) {
     const release = await acquireFileLock(fullPath);
     try {
       if (isDataFile(request.filePath)) {
-        const raw = await fs11.readFile(fullPath, "utf-8");
+        const raw = await fs9.readFile(fullPath, "utf-8");
         const existing = request.filePath.endsWith(".json") ? JSON.parse(raw) : import_yaml2.default.parse(raw);
         const merged = { ...existing ?? {}, ...request.frontmatter };
         const output = request.filePath.endsWith(".json") ? JSON.stringify(merged, null, 2) + `
 ` : import_yaml2.default.stringify(merged);
-        await fs11.writeFile(fullPath, output, "utf-8");
+        await fs9.writeFile(fullPath, output, "utf-8");
       } else {
-        const raw = await fs11.readFile(fullPath, "utf-8");
+        const raw = await fs9.readFile(fullPath, "utf-8");
         const existing = parseFrontmatter3(raw);
         const mergedFrontmatter = {
           ...existing.frontmatter,
@@ -24717,7 +24975,7 @@ async function handleUpdateMarkdown(request, componentDefinitions) {
           finalContent = ensureMdxImports(finalContent, request.filePath, componentDefinitions);
         }
         const markdownContent = serializeFrontmatter(mergedFrontmatter, finalContent);
-        await fs11.writeFile(fullPath, markdownContent, "utf-8");
+        await fs9.writeFile(fullPath, markdownContent, "utf-8");
       }
       return { success: true };
     } finally {
@@ -24740,7 +24998,8 @@ async function handleCreateMarkdown(request) {
     return { success: false, error: `Invalid file extension "${ext}". Allowed: ${allowedExtensions.join(", ")}` };
   }
   const isData = ext === "json" || ext === "yaml" || ext === "yml";
-  const filePath = `src/content/${collection}/${normalizedSlug}.${ext}`;
+  const layout = isData ? "flat" : await detectCollectionMarkdownLayout(collection);
+  const filePath = layout === "index" ? `src/content/${collection}/${normalizedSlug}/index.${ext}` : `src/content/${collection}/${normalizedSlug}.${ext}`;
   const fullPath = resolveAndValidatePath(filePath);
   let fileContent;
   if (isData) {
@@ -24756,8 +25015,8 @@ async function handleCreateMarkdown(request) {
     fileContent = serializeFrontmatter(fullFrontmatter, content);
   }
   try {
-    await fs11.mkdir(path10.dirname(fullPath), { recursive: true });
-    await fs11.writeFile(fullPath, fileContent, { encoding: "utf-8", flag: "wx" });
+    await fs9.mkdir(path9.dirname(fullPath), { recursive: true });
+    await fs9.writeFile(fullPath, fileContent, { encoding: "utf-8", flag: "wx" });
     return {
       success: true,
       filePath,
@@ -24774,8 +25033,8 @@ async function handleCreateMarkdown(request) {
 async function handleDeleteMarkdown(request) {
   try {
     const fullPath = resolveAndValidatePath(request.filePath);
-    await fs11.access(fullPath);
-    await fs11.unlink(fullPath);
+    await fs9.access(fullPath);
+    await fs9.unlink(fullPath);
     return { success: true };
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -24792,16 +25051,16 @@ async function handleRenameMarkdown(request) {
     if (!normalizedSlug) {
       return { success: false, error: "Invalid slug" };
     }
-    const dir = path10.dirname(fullPath);
-    const ext = path10.extname(fullPath);
-    const newFullPath = path10.join(dir, `${normalizedSlug}${ext}`);
+    const dir = path9.dirname(fullPath);
+    const ext = path9.extname(fullPath);
+    const newFullPath = path9.join(dir, `${normalizedSlug}${ext}`);
     if (fullPath === newFullPath) {
       return { success: true, newFilePath: request.filePath, newSlug: normalizedSlug };
     }
     const release = await acquireFileLock(fullPath);
     try {
       try {
-        await fs11.link(fullPath, newFullPath);
+        await fs9.link(fullPath, newFullPath);
       } catch (err) {
         if (isNodeError(err, "EEXIST")) {
           return { success: false, error: `File already exists: ${normalizedSlug}${ext}` };
@@ -24809,16 +25068,16 @@ async function handleRenameMarkdown(request) {
         throw err;
       }
       try {
-        await fs11.unlink(fullPath);
+        await fs9.unlink(fullPath);
       } catch (err) {
-        await fs11.unlink(newFullPath).catch(() => {});
+        await fs9.unlink(newFullPath).catch(() => {});
         throw err;
       }
     } finally {
       release();
     }
     const projectRoot = getProjectRoot();
-    const newFilePath = path10.relative(projectRoot, newFullPath).split(path10.sep).join("/");
+    const newFilePath = path9.relative(projectRoot, newFullPath).split(path9.sep).join("/");
     return { success: true, newFilePath, newSlug: normalizedSlug };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -24828,6 +25087,68 @@ async function handleRenameMarkdown(request) {
 function isDataFile(filePath) {
   return filePath.endsWith(".json") || filePath.endsWith(".yaml") || filePath.endsWith(".yml");
 }
+async function detectCollectionMarkdownLayout(collection) {
+  const existingLayout = await inferLayoutFromExistingEntries(collection);
+  if (existingLayout)
+    return existingLayout;
+  const configLayout = await inferLayoutFromContentConfig(collection);
+  if (configLayout)
+    return configLayout;
+  return "flat";
+}
+async function inferLayoutFromExistingEntries(collection) {
+  const collectionPath = path9.join(getProjectRoot(), "src", "content", collection);
+  let dirEntries;
+  try {
+    dirEntries = await fs9.readdir(collectionPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let flatCount = 0;
+  let indexCount = 0;
+  const flatSlugs = new Set;
+  for (const entry of dirEntries) {
+    if (!entry.isFile())
+      continue;
+    const match = entry.name.match(/^(.+)\.(md|mdx)$/);
+    if (!match)
+      continue;
+    flatCount++;
+    flatSlugs.add(match[1]);
+  }
+  const subdirs = dirEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && !entry.name.startsWith("."));
+  const indexLookups = await Promise.all(subdirs.map(async (dir) => {
+    if (flatSlugs.has(dir.name))
+      return false;
+    for (const ext of ["md", "mdx"]) {
+      try {
+        await fs9.access(path9.join(collectionPath, dir.name, `index.${ext}`));
+        return true;
+      } catch {}
+    }
+    return false;
+  }));
+  indexCount = indexLookups.filter(Boolean).length;
+  if (indexCount > flatCount)
+    return "index";
+  if (flatCount > 0)
+    return "flat";
+  return null;
+}
+async function inferLayoutFromContentConfig(collection) {
+  try {
+    const parsed = await parseContentConfig();
+    const pattern = parsed.get(collection)?.loaderPattern;
+    if (!pattern)
+      return null;
+    return isIndexStyleGlobPattern(pattern) ? "index" : "flat";
+  } catch {
+    return null;
+  }
+}
+function isIndexStyleGlobPattern(pattern) {
+  return pattern.includes("index.{") || pattern.includes("*/index") || pattern.includes("**/index");
+}
 function parseFrontmatter3(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -24910,7 +25231,7 @@ function ensureMdxImports(content, filePath, componentDefinitions) {
     }
   }
   const root = getProjectRoot();
-  const mdxFullPath = path10.join(root, filePath);
+  const mdxFullPath = path9.join(root, filePath);
   const missingImports = [];
   for (const name of usedComponents) {
     if (importedNames.has(name))
@@ -24918,7 +25239,7 @@ function ensureMdxImports(content, filePath, componentDefinitions) {
     const def = componentDefinitions[name];
     if (!def)
       continue;
-    const componentAbsPath = path10.join(root, def.file);
+    const componentAbsPath = path9.join(root, def.file);
     const rel = relativeImportPath(mdxFullPath, componentAbsPath);
     missingImports.push(`import ${name} from '${rel}'`);
   }
@@ -24937,14 +25258,15 @@ function ensureMdxImports(content, filePath, componentDefinitions) {
 var import_yaml2, YAML_DATE_PATTERN;
 var init_markdown_ops = __esm(() => {
   init_config();
+  init_content_config_ast();
   init_utils2();
   import_yaml2 = __toESM(require_dist(), 1);
   YAML_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/;
 });
 
 // ../cms/src/handlers/page-ops.ts
-import fs12 from "fs/promises";
-import path11 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function handleCreatePage(request) {
   const { title, slug } = request;
   const normalizedSlug = slugify(slug || title);
@@ -24956,8 +25278,8 @@ async function handleCreatePage(request) {
   const layoutImport = await resolveLayoutImport(request.layoutPath);
   const content = generatePageContent(title, layoutImport);
   try {
-    await fs12.mkdir(path11.dirname(fullPath), { recursive: true });
-    await fs12.writeFile(fullPath, content, { encoding: "utf-8", flag: "wx" });
+    await fs10.mkdir(path10.dirname(fullPath), { recursive: true });
+    await fs10.writeFile(fullPath, content, { encoding: "utf-8", flag: "wx" });
     const url = normalizedSlug === "index" ? "/" : `/${normalizedSlug}`;
     return { success: true, filePath, slug: normalizedSlug, url };
   } catch (error) {
@@ -24979,7 +25301,7 @@ async function handleDuplicatePage(request) {
   }
   let content;
   try {
-    content = await fs12.readFile(resolveAndValidatePath(sourceFile), "utf-8");
+    content = await fs10.readFile(resolveAndValidatePath(sourceFile), "utf-8");
   } catch {
     return { success: false, error: `Could not read source file: ${sourceFile}` };
   }
@@ -24989,8 +25311,8 @@ async function handleDuplicatePage(request) {
   const newFilePath = `src/pages/${normalizedSlug}.astro`;
   const newFullPath = resolveAndValidatePath(newFilePath);
   try {
-    await fs12.mkdir(path11.dirname(newFullPath), { recursive: true });
-    await fs12.writeFile(newFullPath, content, { encoding: "utf-8", flag: "wx" });
+    await fs10.mkdir(path10.dirname(newFullPath), { recursive: true });
+    await fs10.writeFile(newFullPath, content, { encoding: "utf-8", flag: "wx" });
     const url = normalizedSlug === "index" ? "/" : `/${normalizedSlug}`;
     return { success: true, filePath: newFilePath, slug: normalizedSlug, url };
   } catch (error) {
@@ -25007,7 +25329,7 @@ async function handleDeletePage(request) {
     return { success: false, error: `Page not found: ${pagePath}` };
   }
   try {
-    await fs12.unlink(resolveAndValidatePath(pageFile));
+    await fs10.unlink(resolveAndValidatePath(pageFile));
     return { success: true, filePath: pageFile, url: pagePath };
   } catch (error) {
     if (isNodeError(error, "ENOENT")) {
@@ -25024,10 +25346,10 @@ async function handleCheckSlugExists(slug) {
   return found ? { exists: true, filePath: found } : { exists: false };
 }
 async function handleGetLayouts() {
-  const layoutsDir = path11.join(getProjectRoot(), "src", "layouts");
+  const layoutsDir = path10.join(getProjectRoot(), "src", "layouts");
   let entries;
   try {
-    entries = await fs12.readdir(layoutsDir, { withFileTypes: true });
+    entries = await fs10.readdir(layoutsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -25035,7 +25357,7 @@ async function handleGetLayouts() {
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".astro")) {
       layouts.push({
-        name: path11.basename(entry.name, ".astro"),
+        name: path10.basename(entry.name, ".astro"),
         path: `src/layouts/${entry.name}`
       });
     }
@@ -25047,7 +25369,7 @@ function errorMessage(error) {
 }
 async function fileExists(fullPath) {
   try {
-    await fs12.access(fullPath);
+    await fs10.access(fullPath);
     return true;
   } catch {
     return false;
@@ -25069,7 +25391,7 @@ async function findPageFile(pagePath) {
 }
 async function resolveLayoutImport(layoutPath) {
   if (layoutPath) {
-    const name = path11.basename(layoutPath, ".astro");
+    const name = path10.basename(layoutPath, ".astro");
     const importPath2 = `../${layoutPath.replace(/^src\//, "")}`;
     return { importPath: importPath2, componentName: pascalCase(name) };
   }
@@ -25132,10 +25454,10 @@ var init_page_ops = __esm(() => {
 });
 
 // ../cms/src/handlers/redirect-ops.ts
-import fs13 from "fs/promises";
-import path12 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 function getRedirectsFilePath() {
-  return path12.join(getProjectRoot(), REDIRECTS_FILE);
+  return path11.join(getProjectRoot(), REDIRECTS_FILE);
 }
 async function handleGetRedirects() {
   const lines = await readRedirectsFile(getRedirectsFilePath());
@@ -25212,7 +25534,7 @@ function formatRedirectLine(source, destination, statusCode) {
 }
 async function readRedirectsFile(filePath) {
   try {
-    const content = await fs13.readFile(filePath, "utf-8");
+    const content = await fs11.readFile(filePath, "utf-8");
     return content.split(`
 `);
   } catch (error) {
@@ -25222,16 +25544,16 @@ async function readRedirectsFile(filePath) {
   }
 }
 async function writeRedirectsFile(filePath, lines) {
-  await fs13.mkdir(path12.dirname(filePath), { recursive: true });
+  await fs11.mkdir(path11.dirname(filePath), { recursive: true });
   const trimmed = lines.slice();
   while (trimmed.length > 0 && trimmed[trimmed.length - 1].trim() === "") {
     trimmed.pop();
   }
   if (trimmed.length === 0) {
-    await fs13.writeFile(filePath, "", "utf-8");
+    await fs11.writeFile(filePath, "", "utf-8");
     return;
   }
-  await fs13.writeFile(filePath, trimmed.join(`
+  await fs11.writeFile(filePath, trimmed.join(`
 `) + `
 `, "utf-8");
 }
@@ -31019,8 +31341,8 @@ var init_snippet_utils = __esm(() => {
 });
 
 // ../cms/src/handlers/source-writer.ts
-import fs14 from "fs/promises";
-import path13 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 async function handleUpdate(request, manifestWriter) {
   const { changes, meta } = request;
   const errors = [];
@@ -31050,17 +31372,17 @@ async function handleUpdate(request, manifestWriter) {
       const fullPath = resolveAndValidatePath(filePath);
       const release = await acquireFileLock(fullPath);
       try {
-        const currentContent = await fs14.readFile(fullPath, "utf-8");
+        const currentContent = await fs12.readFile(fullPath, "utf-8");
         const { newContent, appliedCount, failedChanges, fileOps } = await applyChanges(currentContent, fileChanges, manifest, fullPath, meta.url);
         if (failedChanges.length > 0) {
           errors.push(...failedChanges);
         }
         if (appliedCount > 0 && newContent !== currentContent) {
           for (const op of fileOps) {
-            await fs14.mkdir(path13.dirname(op.target), { recursive: true });
-            await fs14.writeFile(op.target, op.bytes);
+            await fs12.mkdir(path12.dirname(op.target), { recursive: true });
+            await fs12.writeFile(op.target, op.bytes);
           }
-          await fs14.writeFile(fullPath, newContent, "utf-8");
+          await fs12.writeFile(fullPath, newContent, "utf-8");
           updated += appliedCount;
         }
       } finally {
@@ -31323,8 +31645,8 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   const resolved = await resolveNewSrcBytes(newSrc, originUrl);
   if (!resolved)
     return null;
-  const originalAssetAbs = path13.resolve(path13.dirname(absFilePath), importInfo.source);
-  const targetAbs = await pickSiblingTarget(path13.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
+  const originalAssetAbs = path12.resolve(path12.dirname(absFilePath), importInfo.source);
+  const targetAbs = await pickSiblingTarget(path12.dirname(originalAssetAbs), resolved.filename, resolved.bytes);
   const newRelImport = relativeImportPath(absFilePath, targetAbs);
   const newContent = content.slice(0, importInfo.sourceStart) + newRelImport + content.slice(importInfo.sourceEnd);
   return {
@@ -31334,11 +31656,11 @@ async function tryRewriteAssetImport(content, importInfo, newSrc, absFilePath, o
   };
 }
 async function resolveNewSrcBytes(newSrc, originUrl) {
-  const filenameFromPath = (p) => path13.basename(p.split("?")[0] ?? p);
-  const diskPath = newSrc.startsWith("/src/") ? path13.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path13.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
+  const filenameFromPath = (p) => path12.basename(p.split("?")[0] ?? p);
+  const diskPath = newSrc.startsWith("/src/") ? path12.join(getProjectRoot(), newSrc.slice(1)) : newSrc.startsWith("/") && !newSrc.startsWith("//") ? path12.join(getProjectRoot(), "public", newSrc.replace(/^\/+/, "")) : null;
   if (diskPath) {
     try {
-      return { bytes: await fs14.readFile(diskPath), filename: filenameFromPath(newSrc) };
+      return { bytes: await fs12.readFile(diskPath), filename: filenameFromPath(newSrc) };
     } catch {}
   }
   try {
@@ -31883,7 +32205,7 @@ var init_source_writer = __esm(() => {
 });
 
 // ../cms/src/handlers/api-routes.ts
-import path14 from "path";
+import path13 from "path";
 function requireMedia(ctx) {
   if (!ctx.mediaAdapter) {
     sendError(ctx.res, "Media storage not configured", 501);
@@ -31973,7 +32295,7 @@ var init_api_routes = __esm(() => {
     }),
     custom("POST", "markdown/delete", async ({ req, res, manifestWriter, contentDir }) => {
       const body = await parseJsonBody(req);
-      const fullPath = path14.resolve(getProjectRoot(), body.filePath?.replace(/^\//, "") ?? "");
+      const fullPath = path13.resolve(getProjectRoot(), body.filePath?.replace(/^\//, "") ?? "");
       expectedDeletions.add(fullPath);
       const result = await handleDeleteMarkdown(body);
       if (result.success) {
@@ -32081,7 +32403,7 @@ var init_api_routes = __esm(() => {
       const body = await parseJsonBody(req);
       const result = await handleDeletePage(body);
       if (result.success && result.filePath) {
-        expectedDeletions.add(path14.resolve(getProjectRoot(), result.filePath));
+        expectedDeletions.add(path13.resolve(getProjectRoot(), result.filePath));
       }
       if (result.success && body.createRedirect && body.redirectTo) {
         await handleAddRedirect({ source: body.pagePath, destination: body.redirectTo, statusCode: 307 });
@@ -32185,8 +32507,8 @@ var init_color_patterns = __esm(() => {
 });
 
 // ../cms/src/tailwind-colors.ts
-import fs15 from "fs/promises";
-import path15 from "path";
+import fs13 from "fs/promises";
+import path14 from "path";
 async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   const cssFiles = [
     "src/styles/global.css",
@@ -32200,9 +32522,9 @@ async function parseTailwindConfig(projectRoot = getProjectRoot()) {
   ];
   let customColors = [];
   for (const cssFile of cssFiles) {
-    const fullPath = path15.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
-      const content = await fs15.readFile(fullPath, "utf-8");
+      const content = await fs13.readFile(fullPath, "utf-8");
       customColors = extractColorsFromCss(content);
       if (customColors.length > 0) {
         break;
@@ -32273,9 +32595,9 @@ async function parseTextStyles(projectRoot = getProjectRoot()) {
   ];
   let customTextStyles = {};
   for (const cssFile of cssFiles) {
-    const fullPath = path15.join(projectRoot, cssFile);
+    const fullPath = path14.join(projectRoot, cssFile);
     try {
-      const content = await fs15.readFile(fullPath, "utf-8");
+      const content = await fs13.readFile(fullPath, "utf-8");
       customTextStyles = extractTextStylesFromCss(content);
       if (Object.values(customTextStyles).some((arr) => arr && arr.length > 0)) {
         break;
@@ -32697,6 +33019,7 @@ var init_tailwind_colors = __esm(() => {
 
 // ../cms/src/html-processor.ts
 var init_html_processor = __esm(() => {
+  init_config();
   init_seo_processor();
   init_tailwind_colors();
   init_utils2();
@@ -32729,8 +33052,8 @@ var init_dev_middleware = __esm(() => {
 });
 
 // ../cms/src/manifest-writer.ts
-import fs16 from "fs/promises";
-import path16 from "path";
+import fs14 from "fs/promises";
+import path15 from "path";
 
 class ManifestWriter {
   globalManifest;
@@ -32801,10 +33124,10 @@ class ManifestWriter {
   }
   getPageManifestPath(pagePath) {
     if (pagePath === "/" || pagePath === "") {
-      return path16.join(this.outDir, "index.json");
+      return path15.join(this.outDir, "index.json");
     }
     const cleanPath = pagePath.replace(/^\//, "");
-    return path16.join(this.outDir, `${cleanPath}.json`);
+    return path15.join(this.outDir, `${cleanPath}.json`);
   }
   addPage(pagePath, entries, components, collection, seo) {
     this.pageManifests.set(pagePath, { entries, components, collection, seo });
@@ -32830,8 +33153,8 @@ class ManifestWriter {
   }
   async writePageManifest(pagePath, entries, components, collection, seo) {
     const manifestPath = this.getPageManifestPath(pagePath);
-    const manifestDir = path16.dirname(manifestPath);
-    await fs16.mkdir(manifestDir, { recursive: true });
+    const manifestDir = path15.dirname(manifestPath);
+    await fs14.mkdir(manifestDir, { recursive: true });
     const metadata = {
       version: MANIFEST_VERSION,
       generatedAt: new Date().toISOString(),
@@ -32852,7 +33175,7 @@ class ManifestWriter {
     if (seo) {
       pageManifest.seo = seo;
     }
-    await fs16.writeFile(manifestPath, JSON.stringify(pageManifest, null, 2), "utf-8");
+    await fs14.writeFile(manifestPath, JSON.stringify(pageManifest, null, 2), "utf-8");
   }
   async finalize() {
     await this.writeQueue;
@@ -32881,7 +33204,7 @@ class ManifestWriter {
       }
     }
     if (this.outDir) {
-      const globalManifestPath = path16.join(this.outDir, this.manifestFile);
+      const globalManifestPath = path15.join(this.outDir, this.manifestFile);
       const globalSettings = {
         componentDefinitions: this.componentDefinitions,
         pages
@@ -32895,7 +33218,7 @@ class ManifestWriter {
       if (this.availableTextStyles) {
         globalSettings.availableTextStyles = this.availableTextStyles;
       }
-      await fs16.writeFile(globalManifestPath, JSON.stringify(globalSettings, null, 2), "utf-8");
+      await fs14.writeFile(globalManifestPath, JSON.stringify(globalSettings, null, 2), "utf-8");
     }
     return {
       totalEntries: Object.keys(this.globalManifest.entries).length,
@@ -32961,17 +33284,533 @@ var init_vite_plugin = __esm(() => {
   init_vite_plugin_array_transform();
 });
 
+// ../../node_modules/zod/v4/core/core.js
+function $constructor(name, initializer, params) {
+  function init2(inst, def) {
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _2,
+          traits: new Set
+        },
+        enumerable: false
+      });
+    }
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    const proto = _2.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0;i < keys.length; i++) {
+      const k = keys[i];
+      if (!(k in inst)) {
+        inst[k] = proto[k].bind(inst);
+      }
+    }
+  }
+  const Parent = params?.Parent ?? Object;
+
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _2(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition : this;
+    init2(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_2, "init", { value: init2 });
+  Object.defineProperty(_2, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_2, "name", { value: name });
+  return _2;
+}
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+var NEVER, $brand, globalConfig;
+var init_core = __esm(() => {
+  NEVER = Object.freeze({
+    status: "aborted"
+  });
+  $brand = Symbol("zod_brand");
+  globalConfig = {};
+});
+
+// ../../node_modules/zod/v4/core/util.js
+function joinValues(array, separator = "|") {
+  return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_2, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function stringifyPrimitive(value) {
+  if (typeof value === "bigint")
+    return value.toString() + "n";
+  if (typeof value === "string")
+    return `"${value}"`;
+  return `${value}`;
+}
+function parsedType(data) {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "nan" : "number";
+    }
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      const obj = data;
+      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+        return obj.constructor.name;
+      }
+    }
+  }
+  return t;
+}
+var EVALUATING, captureStackTrace, allowsEval, propertyKeyTypes, primitiveTypes, NUMBER_FORMAT_RANGES;
+var init_util = __esm(() => {
+  EVALUATING = Symbol("evaluating");
+  captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+  allowsEval = cached(() => {
+    if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+      return false;
+    }
+    try {
+      const F = Function;
+      new F("");
+      return true;
+    } catch (_2) {
+      return false;
+    }
+  });
+  propertyKeyTypes = new Set(["string", "number", "symbol"]);
+  primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+  NUMBER_FORMAT_RANGES = {
+    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+    float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+  };
+});
+
+// ../../node_modules/zod/v4/core/errors.js
+function flattenError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
+    } else {
+      formErrors.push(mapper(sub));
+    }
+  }
+  return { formErrors, fieldErrors };
+}
+function formatError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = { _errors: [] };
+  const processError = (error2) => {
+    for (const issue of error2.issues) {
+      if (issue.code === "invalid_union" && issue.errors.length) {
+        issue.errors.map((issues) => processError({ issues }));
+      } else if (issue.code === "invalid_key") {
+        processError({ issues: issue.issues });
+      } else if (issue.code === "invalid_element") {
+        processError({ issues: issue.issues });
+      } else if (issue.path.length === 0) {
+        fieldErrors._errors.push(mapper(issue));
+      } else {
+        let curr = fieldErrors;
+        let i = 0;
+        while (i < issue.path.length) {
+          const el = issue.path[i];
+          const terminal = i === issue.path.length - 1;
+          if (!terminal) {
+            curr[el] = curr[el] || { _errors: [] };
+          } else {
+            curr[el] = curr[el] || { _errors: [] };
+            curr[el]._errors.push(mapper(issue));
+          }
+          curr = curr[el];
+          i++;
+        }
+      }
+    }
+  };
+  processError(error);
+  return fieldErrors;
+}
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+}, $ZodError, $ZodRealError;
+var init_errors = __esm(() => {
+  init_core();
+  init_util();
+  $ZodError = $constructor("$ZodError", initializer);
+  $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+});
+
+// ../../node_modules/zod/v4/core/parse.js
+var init_parse = () => {};
+
+// ../../node_modules/zod/v4/core/regexes.js
+var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date;
+var init_regexes = __esm(() => {
+  date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+});
+
+// ../../node_modules/zod/v4/core/checks.js
+var init_checks = () => {};
+
+// ../../node_modules/zod/v4/core/versions.js
+var init_versions = () => {};
+
+// ../../node_modules/zod/v4/core/schemas.js
+var init_schemas = () => {};
+
+// ../../node_modules/zod/v4/locales/en.js
+function en_default() {
+  return {
+    localeError: error()
+  };
+}
+var error = () => {
+  const Sizable = {
+    string: { unit: "characters", verb: "to have" },
+    file: { unit: "bytes", verb: "to have" },
+    array: { unit: "items", verb: "to have" },
+    set: { unit: "items", verb: "to have" },
+    map: { unit: "entries", verb: "to have" }
+  };
+  function getSizing(origin) {
+    return Sizable[origin] ?? null;
+  }
+  const FormatDictionary = {
+    regex: "input",
+    email: "email address",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO datetime",
+    date: "ISO date",
+    time: "ISO time",
+    duration: "ISO duration",
+    ipv4: "IPv4 address",
+    ipv6: "IPv6 address",
+    mac: "MAC address",
+    cidrv4: "IPv4 range",
+    cidrv6: "IPv6 range",
+    base64: "base64-encoded string",
+    base64url: "base64url-encoded string",
+    json_string: "JSON string",
+    e164: "E.164 number",
+    jwt: "JWT",
+    template_literal: "input"
+  };
+  const TypeDictionary = {
+    nan: "NaN"
+  };
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        return `Invalid input: expected ${expected}, received ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
+        return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+        return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+        return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue;
+        if (_issue.format === "starts_with") {
+          return `Invalid string: must start with "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with")
+          return `Invalid string: must end with "${_issue.suffix}"`;
+        if (_issue.format === "includes")
+          return `Invalid string: must include "${_issue.includes}"`;
+        if (_issue.format === "regex")
+          return `Invalid string: must match pattern ${_issue.pattern}`;
+        return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Invalid number: must be a multiple of ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Invalid key in ${issue.origin}`;
+      case "invalid_union":
+        return "Invalid input";
+      case "invalid_element":
+        return `Invalid value in ${issue.origin}`;
+      default:
+        return `Invalid input`;
+    }
+  };
+};
+var init_en = __esm(() => {
+  init_util();
+});
+
+// ../../node_modules/zod/v4/locales/index.js
+var init_locales = () => {};
+
+// ../../node_modules/zod/v4/core/registries.js
+class $ZodRegistry {
+  constructor() {
+    this._map = new WeakMap;
+    this._idmap = new Map;
+  }
+  add(schema, ..._meta) {
+    const meta = _meta[0];
+    this._map.set(schema, meta);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.set(meta.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = new WeakMap;
+    this._idmap = new Map;
+    return this;
+  }
+  remove(schema) {
+    const meta = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ...this.get(p) ?? {} };
+      delete pm.id;
+      const f = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f).length ? f : undefined;
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+}
+function registry() {
+  return new $ZodRegistry;
+}
+var _a, $output, $input, globalRegistry;
+var init_registries = __esm(() => {
+  $output = Symbol("ZodOutput");
+  $input = Symbol("ZodInput");
+  (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+  globalRegistry = globalThis.__zod_globalRegistry;
+});
+
+// ../../node_modules/zod/v4/core/api.js
+var init_api = () => {};
+
+// ../../node_modules/zod/v4/core/to-json-schema.js
+var init_to_json_schema = () => {};
+
+// ../../node_modules/zod/v4/core/json-schema.js
+var init_json_schema = () => {};
+
+// ../../node_modules/zod/v4/core/index.js
+var init_core2 = __esm(() => {
+  init_util();
+  init_regexes();
+  init_locales();
+  init_json_schema();
+  init_core();
+  init_parse();
+  init_errors();
+  init_schemas();
+  init_checks();
+  init_versions();
+  init_registries();
+  init_api();
+  init_to_json_schema();
+});
+
+// ../../node_modules/zod/v4/classic/checks.js
+var init_checks2 = () => {};
+
+// ../../node_modules/zod/v4/classic/iso.js
+var init_iso = () => {};
+
+// ../../node_modules/zod/v4/classic/errors.js
+var initializer2 = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => formatError(inst, mapper)
+    },
+    flatten: {
+      value: (mapper) => flattenError(inst, mapper)
+    },
+    addIssue: {
+      value: (issue) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    addIssues: {
+      value: (issues2) => {
+        inst.issues.push(...issues2);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+    }
+  });
+}, ZodError, ZodRealError;
+var init_errors2 = __esm(() => {
+  init_core2();
+  init_core2();
+  init_util();
+  ZodError = $constructor("ZodError", initializer2);
+  ZodRealError = $constructor("ZodError", initializer2, {
+    Parent: Error
+  });
+});
+
+// ../../node_modules/zod/v4/classic/parse.js
+var init_parse2 = () => {};
+
+// ../../node_modules/zod/v4/classic/schemas.js
+var init_schemas2 = () => {};
+
+// ../../node_modules/zod/v4/classic/compat.js
+var ZodFirstPartyTypeKind;
+var init_compat = __esm(() => {
+  (function(ZodFirstPartyTypeKind2) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+});
+
+// ../../node_modules/zod/v4/classic/coerce.js
+var init_coerce = () => {};
+
+// ../../node_modules/zod/v4/classic/external.js
+var init_external = __esm(() => {
+  init_core2();
+  init_core2();
+  init_en();
+  init_locales();
+  init_iso();
+  init_coerce();
+  init_schemas2();
+  init_checks2();
+  init_errors2();
+  init_parse2();
+  init_compat();
+  config(en_default());
+});
+
+// ../../node_modules/zod/v4/classic/index.js
+var init_classic = __esm(() => {
+  init_external();
+});
+
+// ../../node_modules/zod/v4/index.js
+var init_v4 = __esm(() => {
+  init_classic();
+});
+
+// ../../node_modules/astro/dist/zod.js
+var init_zod = __esm(() => {
+  init_v4();
+});
+
 // ../cms/src/field-types.ts
-import { z } from "astro/zod";
-var init_field_types = () => {};
+var init_field_types = __esm(() => {
+  init_zod();
+});
 // ../cms/src/media/s3.ts
 var init_s3 = __esm(() => {
   init_local();
 });
 
 // ../cms/src/migrate-astro-image.ts
-import fs17 from "fs/promises";
-import path17 from "path";
+import fs15 from "fs/promises";
+import path16 from "path";
 async function migrateAstroImages(options = {}) {
   const projectRoot = options.projectRoot ?? getProjectRoot();
   const dryRun = options.dryRun ?? false;
@@ -32983,10 +33822,10 @@ async function migrateAstroImages(options = {}) {
     if (astroFields.length === 0 || !def.entries)
       continue;
     for (const entry of def.entries) {
-      const entryAbs = path17.isAbsolute(entry.sourcePath) ? entry.sourcePath : path17.join(projectRoot, entry.sourcePath);
+      const entryAbs = path16.isAbsolute(entry.sourcePath) ? entry.sourcePath : path16.join(projectRoot, entry.sourcePath);
       let raw;
       try {
-        raw = await fs17.readFile(entryAbs, "utf-8");
+        raw = await fs15.readFile(entryAbs, "utf-8");
       } catch {
         skipped.push({ entrySourcePath: entry.sourcePath, fieldName: "*", reason: "read failed" });
         continue;
@@ -32997,10 +33836,10 @@ async function migrateAstroImages(options = {}) {
         continue;
       }
       const [fullFm, fmStart, yamlBody, fmEnd] = fmMatch;
-      const doc = import_yaml6.parseDocument(yamlBody);
+      const doc2 = import_yaml6.parseDocument(yamlBody);
       let mutated = false;
       for (const field of astroFields) {
-        const current = doc.get(field.name);
+        const current = doc2.get(field.name);
         if (typeof current !== "string") {
           if (current != null)
             skipped.push({ entrySourcePath: entry.sourcePath, fieldName: field.name, reason: "non-string value" });
@@ -33008,10 +33847,10 @@ async function migrateAstroImages(options = {}) {
         }
         if (!current.startsWith("/") || current.startsWith("//"))
           continue;
-        const sourceAbs = path17.join(projectRoot, "public", current.replace(/^\/+/, ""));
+        const sourceAbs = path16.join(projectRoot, "public", current.replace(/^\/+/, ""));
         let sourceBuf;
         try {
-          sourceBuf = await fs17.readFile(sourceAbs);
+          sourceBuf = await fs15.readFile(sourceAbs);
         } catch {
           skipped.push({ entrySourcePath: entry.sourcePath, fieldName: field.name, reason: `source missing: ${sourceAbs}` });
           continue;
@@ -33019,14 +33858,14 @@ async function migrateAstroImages(options = {}) {
         const target = await pickAstroImageTarget({
           entryAbsPath: entryAbs,
           slug: entry.slug,
-          originalFilename: path17.basename(current),
+          originalFilename: path16.basename(current),
           compareBuffer: sourceBuf
         });
         if (!dryRun) {
-          await fs17.mkdir(path17.dirname(target.absPath), { recursive: true });
-          await fs17.writeFile(target.absPath, sourceBuf);
+          await fs15.mkdir(path16.dirname(target.absPath), { recursive: true });
+          await fs15.writeFile(target.absPath, sourceBuf);
         }
-        doc.set(field.name, target.relPath);
+        doc2.set(field.name, target.relPath);
         mutated = true;
         migrations.push({
           entrySourcePath: entry.sourcePath,
@@ -33038,9 +33877,9 @@ async function migrateAstroImages(options = {}) {
         });
       }
       if (mutated && !dryRun) {
-        const newYaml = doc.toString().replace(/\n$/, "");
+        const newYaml = doc2.toString().replace(/\n$/, "");
         const newRaw = raw.replace(fullFm, `${fmStart}${newYaml}${fmEnd}`);
-        await fs17.writeFile(entryAbs, newRaw, "utf-8");
+        await fs15.writeFile(entryAbs, newRaw, "utf-8");
       }
     }
   }
@@ -33082,7 +33921,7 @@ var exports_migrate = {};
 __export(exports_migrate, {
   migrate: () => migrate
 });
-import path18 from "path";
+import path17 from "path";
 async function migrate(args) {
   if (args.target !== "astro-image") {
     console.error(`Unknown migrate target: ${args.target}`);
@@ -33101,7 +33940,7 @@ async function migrate(args) {
     for (const m of result.migrations) {
       console.log(`  ${m.entrySourcePath}`);
       console.log(`    ${m.fieldName}: ${m.originalValue} \u2192 ${m.newValue}`);
-      console.log(`      copy: ${path18.relative(process.cwd(), m.copiedFrom)} \u2192 ${path18.relative(process.cwd(), m.copiedTo)}`);
+      console.log(`      copy: ${path17.relative(process.cwd(), m.copiedFrom)} \u2192 ${path17.relative(process.cwd(), m.copiedTo)}`);
     }
   }
   if (result.skipped.length > 0) {
@@ -33120,224 +33959,9 @@ var init_migrate = __esm(() => {
   init_src();
 });
 
-// ../agent-summary/src/agent-summary-integration.ts
-import fs2 from "fs/promises";
-import { fileURLToPath } from "url";
-
-// ../agent-summary/src/utils.ts
-import { promises as fs } from "fs";
-import path from "path";
-var AGENTS_PATH = path.resolve("AGENTS.md");
-var SUMMARY_START = "<page_summary>";
-var SUMMARY_END = "</page_summary>";
-var decodeEntities = (value) => {
-  return value.replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&nbsp;/gi, " ");
-};
-var sanitize = (value) => {
-  if (!value) {
-    return "";
-  }
-  const decoded = decodeEntities(value);
-  return decoded.replace(/\s+/g, " ").replace(/[\u2012-\u2015]/g, "-").replace(/\u2026/g, "...").trim();
-};
-var truncate = (value, maxLength) => {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.slice(0, maxLength - 3).trimEnd()}...`;
-};
-var normalizeRoute = (pathname) => {
-  const trimmed = pathname.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed.length === 0) {
-    return "/";
-  }
-  return `/${trimmed}`;
-};
-var formatDestination = (value) => {
-  if (!value) {
-    return "/";
-  }
-  if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value) || value.startsWith("#")) {
-    return value;
-  }
-  return normalizeRoute(value);
-};
-var resolveHtmlPath = async (distDir, pathname) => {
-  const normalizedRoute = normalizeRoute(pathname);
-  const routeSegment = normalizedRoute === "/" ? "" : normalizedRoute.slice(1);
-  const candidates = routeSegment === "" ? [path.join(distDir, "index.html")] : [
-    path.join(distDir, routeSegment, "index.html"),
-    path.join(distDir, `${routeSegment}.html`)
-  ];
-  for (const candidate of candidates) {
-    try {
-      const stats = await fs.stat(candidate);
-      if (stats.isFile()) {
-        return candidate;
-      }
-    } catch {}
-  }
-  return null;
-};
-var extractMetaFromHtml = (route, html) => {
-  const titleMatch = html.match(/<title[^>]*>([^<]*)<\/title>/i);
-  const metaMatch = html.match(/<meta[^>]+name=["']description["'][^>]*?>/i);
-  const contentMatch = metaMatch?.[0]?.match(/content=["']([^"']*)["']/i);
-  const headingMatches = [...html.matchAll(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi)];
-  const headingEntries = headingMatches.map((match) => ({
-    level: `h${match[1]}`,
-    text: sanitize(match[2]?.replace(/<[^>]+>/g, ""))
-  })).filter((entry) => entry.text.length > 0);
-  const primaryHeading = headingEntries.find((entry) => entry.level === "h1" && entry.text.length >= 8) || headingEntries.find((entry) => entry.text.length >= 16) || headingEntries[0];
-  const primaryHeadingText = primaryHeading?.text ?? "";
-  const paragraphMatches = [...html.matchAll(/<p[^>]*>([\s\S]*?)<\/p>/gi)];
-  const paragraphCandidates = paragraphMatches.map((match) => sanitize(match[1]?.replace(/<[^>]+>/g, "")));
-  const fallbackParagraph = paragraphCandidates.find((text) => text.length >= 40) ?? paragraphCandidates[0] ?? "";
-  const title = sanitize(titleMatch?.[1] ?? (primaryHeadingText || "Untitled page"));
-  const descriptionSource = contentMatch?.[1];
-  const paragraphDescription = descriptionSource ? "" : fallbackParagraph;
-  const description = truncate((descriptionSource ? sanitize(descriptionSource) : paragraphDescription) || "Description unavailable", 220);
-  return {
-    route: normalizeRoute(route),
-    title,
-    description,
-    headlines: headingEntries
-  };
-};
-var createJsonlRecords = (pages, redirects) => {
-  const records = [];
-  for (const page of pages.sort((a, b) => a.route.localeCompare(b.route))) {
-    records.push(JSON.stringify({
-      kind: "page",
-      route: page.route,
-      title: page.title,
-      description: page.description,
-      headlines: page.headlines
-    }));
-  }
-  for (const redirect of redirects.sort((a, b) => a.from.localeCompare(b.from))) {
-    records.push(JSON.stringify({
-      kind: "redirect",
-      route: redirect.from,
-      to: redirect.to,
-      status: redirect.status
-    }));
-  }
-  return records;
-};
-var updateAgentsSummary = async (pages, redirects) => {
-  const jsonlRecords = createJsonlRecords(pages, redirects);
-  const summaryBody = jsonlRecords.join(`
-`);
-  const summaryBlock = summaryBody ? `${SUMMARY_START}
-${summaryBody}
-${SUMMARY_END}
-` : `${SUMMARY_START}
-${SUMMARY_END}
-`;
-  const agentsContent = await fs.readFile(AGENTS_PATH, "utf8").catch(() => "");
-  if (agentsContent.includes(SUMMARY_START) && agentsContent.includes(SUMMARY_END)) {
-    const startIndex = agentsContent.indexOf(SUMMARY_START);
-    const summaryEndIndex = agentsContent.indexOf(SUMMARY_END, startIndex);
-    if (summaryEndIndex === -1) {
-      const recovered = `${agentsContent.slice(0, startIndex)}${summaryBlock}`;
-      await fs.writeFile(AGENTS_PATH, recovered, "utf8");
-      return;
-    }
-    let endIndex = summaryEndIndex + SUMMARY_END.length;
-    while (endIndex < agentsContent.length && (agentsContent[endIndex] === `
-` || agentsContent[endIndex] === "\r")) {
-      endIndex += 1;
-    }
-    const updated = `${agentsContent.slice(0, startIndex)}${summaryBlock}${agentsContent.slice(endIndex)}`;
-    await fs.writeFile(AGENTS_PATH, updated, "utf8");
-    return;
-  }
-  const prefix = agentsContent.trimEnd();
-  const separator = prefix.length === 0 ? "" : `
-`;
-  await fs.writeFile(AGENTS_PATH, `${prefix}${separator}${summaryBlock}`, "utf8");
-};
-
-// ../agent-summary/src/agent-summary-integration.ts
-var agentsSummary = () => {
-  const redirectPathnames = new Set;
-  const redirects = [];
-  return {
-    name: "agents-summary",
-    hooks: {
-      "astro:routes:resolved": ({ routes }) => {
-        redirectPathnames.clear();
-        redirects.length = 0;
-        for (const route of routes) {
-          if (route.type === "redirect" && route.pathname) {
-            const from = normalizeRoute(route.pathname);
-            redirectPathnames.add(from);
-            let destination = "";
-            let status = "";
-            const redirectConfig = route.redirect;
-            if (typeof redirectConfig === "string") {
-              destination = redirectConfig;
-              status = "302";
-            } else if (redirectConfig) {
-              destination = redirectConfig.destination;
-              status = redirectConfig.status?.toString() ?? "";
-            } else if (route.redirectRoute?.pathname) {
-              destination = route.redirectRoute.pathname;
-            }
-            let resolvedDestination = destination;
-            if (!resolvedDestination && route.redirectRoute?.pattern) {
-              resolvedDestination = route.redirectRoute.pattern.toString();
-            }
-            const to = resolvedDestination?.startsWith("^") ? resolvedDestination : formatDestination(resolvedDestination);
-            redirects.push({
-              from,
-              to,
-              status: status || "302"
-            });
-          }
-        }
-      },
-      "astro:build:done": async ({ dir, pages, logger }) => {
-        const distDir = fileURLToPath(dir);
-        const summaries = [];
-        for (const page of pages) {
-          const route = normalizeRoute(page.pathname);
-          if (redirectPathnames.has(route)) {
-            continue;
-          }
-          const htmlPath = await resolveHtmlPath(distDir, page.pathname);
-          if (!htmlPath) {
-            logger.warn(`Skipping ${page.pathname}; no HTML output found.`);
-            continue;
-          }
-          const html = await fs2.readFile(htmlPath, "utf8");
-          summaries.push(extractMetaFromHtml(page.pathname, html));
-        }
-        if (summaries.length === 0) {
-          logger.warn("No pages detected; AGENTS.md was not updated.");
-          return;
-        }
-        await updateAgentsSummary(summaries, redirects);
-        logger.info(`Updated AGENTS.md with ${summaries.length} page entries${redirects.length > 0 ? ` and ${redirects.length} redirects` : ""}.`);
-      }
-    }
-  };
-};
 // src/index.ts
-init_utils();
-import { build as astroBuild, dev, preview } from "astro";
 import { spawn } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
 var [, , command, ...args] = process.argv;
-function hasNuaIntegration(configPath) {
-  try {
-    const content = readFileSync3(configPath, "utf-8");
-    return content.includes("@nuasite/agent-summary") || content.includes("agentsSummary");
-  } catch {
-    return false;
-  }
-}
 function proxyToAstroCLI(command2, args2) {
   const astro = spawn("npx", ["astro", command2, ...args2], {
     stdio: "inherit",
@@ -33346,8 +33970,8 @@ function proxyToAstroCLI(command2, args2) {
   astro.on("close", (code) => {
     process.exit(code || 0);
   });
-  astro.on("error", (error) => {
-    console.error("Error running astro command:", error);
+  astro.on("error", (error2) => {
+    console.error("Error running astro command:", error2);
     process.exit(1);
   });
 }
@@ -33366,45 +33990,10 @@ Commands:`);
 All Astro CLI options are supported.
 `);
 }
-var configPath = findAstroConfig();
-var canProxyDirectly = configPath && hasNuaIntegration(configPath);
-if (canProxyDirectly && command && ["build", "dev", "preview"].includes(command)) {
+if (command && ["build", "dev", "preview"].includes(command)) {
   proxyToAstroCLI(command, args);
 } else {
   switch (command) {
-    case "build":
-      astroBuild({
-        root: process.cwd(),
-        integrations: [agentsSummary()]
-      }).catch((error) => {
-        console.error("Error:", error);
-        process.exit(1);
-      });
-      break;
-    case "dev":
-    case "preview": {
-      const server = {};
-      for (let i = 0;i < args.length; i++) {
-        if (args[i] === "--port" && args[i + 1]) {
-          server.port = parseInt(args[i + 1], 10);
-          i++;
-        } else if (args[i] === "--host" && args[i + 1]) {
-          server.host = args[i + 1];
-          i++;
-        }
-      }
-      const options = {
-        root: process.cwd(),
-        integrations: [agentsSummary()],
-        server
-      };
-      const runner = command === "dev" ? dev : preview;
-      runner(options).catch((error) => {
-        console.error("Error:", error);
-        process.exit(1);
-      });
-      break;
-    }
     case "init": {
       const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
       await init2({