@sonicjs-cms/core 2.9.0 → 2.10.0

package/dist/{chunk-2JGQKF7B.js → chunk-JTNUM7JE.js}

@@ -1,10 +1,10 @@
 import { getCacheService, CACHE_CONFIGS, getLogger, SettingsService, getAppInstance, buildRouteList, CATEGORY_INFO } from './chunk-7JMMLHPQ.js';
-import { requireAuth, isPluginActive, optionalAuth, requireRole, rateLimit, AuthManager, logActivity, generateCsrfToken } from './chunk-25YNV4RK.js';
-import { PluginService } from './chunk-YFJJU26H.js';
-import { MigrationService } from './chunk-STTZVLY2.js';
+import { requireAuth, requireRole, isPluginActive, optionalAuth, rateLimit, AuthManager, logActivity, generateCsrfToken } from './chunk-4TTMQQC7.js';
+import { PluginService } from './chunk-27AOVQTR.js';
+import { MigrationService } from './chunk-6O3RJV3C.js';
 import { init_admin_layout_catalyst_template, renderDesignPage, renderCheckboxPage, renderTestimonialsList, renderCodeExamplesList, renderAlert, renderTable, renderPagination, renderConfirmationDialog, getConfirmationDialogScript, renderAdminLayoutCatalyst, renderAdminLayout, adminLayoutV2, renderForm } from './chunk-JJS7JZCH.js';
 import { PluginBuilder, TurnstileService } from './chunk-J5WGMRSU.js';
-import { QueryFilterBuilder, getCoreVersion, getBlocksFieldConfig, parseBlocksValue } from './chunk-3FHMXGLF.js';
+import { QueryFilterBuilder, getCoreVersion, getBlocksFieldConfig, parseBlocksValue } from './chunk-IZWNIUJI.js';
 import { metricsTracker } from './chunk-FICTAGD4.js';
 import { escapeHtml, sanitizeRichText, sanitizeInput } from './chunk-TQABQWOP.js';
 import { Hono } from 'hono';
@@ -119,7 +119,7 @@ apiContentCrudRoutes.get("/:id", async (c) => {
     }, 500);
   }
 });
-apiContentCrudRoutes.post("/", requireAuth(), async (c) => {
+apiContentCrudRoutes.post("/", requireAuth(), requireRole(["admin", "editor", "author"]), async (c) => {
   try {
     const db = c.env.DB;
     const user = c.get("user");
@@ -185,7 +185,7 @@ apiContentCrudRoutes.post("/", requireAuth(), async (c) => {
     }, 500);
   }
 });
-apiContentCrudRoutes.put("/:id", requireAuth(), async (c) => {
+apiContentCrudRoutes.put("/:id", requireAuth(), requireRole(["admin", "editor", "author"]), async (c) => {
   try {
     const id = c.req.param("id");
     const db = c.env.DB;
@@ -249,7 +249,7 @@ apiContentCrudRoutes.put("/:id", requireAuth(), async (c) => {
     }, 500);
   }
 });
-apiContentCrudRoutes.delete("/:id", requireAuth(), async (c) => {
+apiContentCrudRoutes.delete("/:id", requireAuth(), requireRole(["admin", "editor", "author"]), async (c) => {
   try {
     const id = c.req.param("id");
     const db = c.env.DB;
@@ -2281,7 +2281,7 @@ adminApiRoutes.delete("/collections/:id", async (c) => {
 });
 adminApiRoutes.get("/migrations/status", async (c) => {
   try {
-    const { MigrationService: MigrationService2 } = await import('./migrations-SZSR3C3G.js');
+    const { MigrationService: MigrationService2 } = await import('./migrations-N2C2VPJU.js');
     const db = c.env.DB;
     const migrationService = new MigrationService2(db);
     const status = await migrationService.getMigrationStatus();
@@ -2306,7 +2306,7 @@ adminApiRoutes.post("/migrations/run", async (c) => {
         error: "Unauthorized. Admin access required."
       }, 403);
     }
-    const { MigrationService: MigrationService2 } = await import('./migrations-SZSR3C3G.js');
+    const { MigrationService: MigrationService2 } = await import('./migrations-N2C2VPJU.js');
     const db = c.env.DB;
     const migrationService = new MigrationService2(db);
     const result = await migrationService.runPendingMigrations();
@@ -2325,7 +2325,7 @@ adminApiRoutes.post("/migrations/run", async (c) => {
 });
 adminApiRoutes.get("/migrations/validate", async (c) => {
   try {
-    const { MigrationService: MigrationService2 } = await import('./migrations-SZSR3C3G.js');
+    const { MigrationService: MigrationService2 } = await import('./migrations-N2C2VPJU.js');
     const db = c.env.DB;
     const migrationService = new MigrationService2(db);
     const validation = await migrationService.validateSchema();
@@ -4775,6 +4775,39 @@ function getReadFieldValueScript() {
         window.__sonicReadFieldValueInit = true;
 
         window.sonicReadFieldValue = function(fieldWrapper) {
+          const getDirectChild = (parent, selector) => {
+            if (!(parent instanceof Element)) return null;
+            return Array.from(parent.children).find(
+              (child) => child instanceof Element && child.matches(selector),
+            ) || null;
+          };
+          const getDirectStructuredSubfields = (host) =>
+            Array.from(host.children).filter(
+              (child) => child instanceof Element && child.classList.contains('structured-subfield'),
+            );
+          const getStructuredObjectFieldsHost = (container) => {
+            const directFieldsHost = getDirectChild(container, '[data-structured-object-fields]');
+            if (directFieldsHost) return directFieldsHost;
+            const groupContent = getDirectChild(container, '.field-group-content');
+            const nestedFieldsHost = groupContent
+              ? getDirectChild(groupContent, '[data-structured-object-fields]')
+              : null;
+            if (nestedFieldsHost) return nestedFieldsHost;
+            return getDirectChild(container, '[data-array-item-fields]') || container;
+          };
+          const getDirectStructuredObject = (fieldWrapper) => {
+            const directObject = getDirectChild(fieldWrapper, '[data-structured-object]');
+            if (directObject) return directObject;
+            const formGroup = getDirectChild(fieldWrapper, '.form-group');
+            return formGroup ? getDirectChild(formGroup, '[data-structured-object]') : null;
+          };
+          const getDirectStructuredArray = (fieldWrapper) => {
+            const directArray = getDirectChild(fieldWrapper, '[data-structured-array]');
+            if (directArray) return directArray;
+            const formGroup = getDirectChild(fieldWrapper, '.form-group');
+            return formGroup ? getDirectChild(formGroup, '[data-structured-array]') : null;
+          };
+
           const fieldType = fieldWrapper.dataset.fieldType;
           const select = fieldWrapper.querySelector('select');
           const textarea = fieldWrapper.querySelector('textarea');
@@ -4784,7 +4817,47 @@ function getReadFieldValueScript() {
           const nonHiddenInput = inputs.find((input) => input.type !== 'hidden' && input.type !== 'checkbox');
           const hiddenInput = inputs.find((input) => input.type === 'hidden');
 
+          const readStructuredFieldsHost = (host) => {
+            const fields = getDirectStructuredSubfields(host);
+            if (fields.length === 1 && fields[0].dataset.structuredField === '__value') {
+              return window.sonicReadFieldValue(fields[0]);
+            }
+            return fields.reduce((acc, subfield) => {
+              const fieldName = subfield.dataset.structuredField;
+              if (!fieldName || fieldName === '__value') return acc;
+              acc[fieldName] = window.sonicReadFieldValue(subfield);
+              return acc;
+            }, {});
+          };
+
+          const readStructuredObject = () => {
+            const objectContainer = getDirectStructuredObject(fieldWrapper);
+            if (!objectContainer) return null;
+            const host = getStructuredObjectFieldsHost(objectContainer);
+            return readStructuredFieldsHost(host);
+          };
+
+          const readStructuredArray = () => {
+            const arrayContainer = getDirectStructuredArray(fieldWrapper);
+            if (!arrayContainer) return null;
+            const list = arrayContainer.querySelector('[data-structured-array-list]');
+            if (!list) return [];
+            const items = Array.from(list.querySelectorAll(':scope > .structured-array-item'));
+            return items.map((item) => {
+              const host =
+                item.querySelector(':scope > [data-array-item-fields]') ||
+                item.querySelector('[data-array-item-fields]') ||
+                item;
+              return readStructuredFieldsHost(host);
+            });
+          };
+
           if (fieldType === 'object' || fieldType === 'array') {
+            const liveValue = fieldType === 'array' ? readStructuredArray() : readStructuredObject();
+            if (liveValue !== null) {
+              return liveValue;
+            }
+
             if (!hiddenInput) {
               return fieldType === 'array' ? [] : {};
             }
@@ -4833,6 +4906,15 @@ function getReadFieldValueScript() {
     </script>
   `;
 }
+var STRUCTURED_INDEX_TOKEN = "__INDEX__";
+var BLOCK_INDEX_TOKEN = "__BLOCK_INDEX__";
+function sanitizeStructuredGroupId(fieldName) {
+  return `object-${fieldName}`.split(BLOCK_INDEX_TOKEN).map(
+    (blockSegment) => blockSegment.split(STRUCTURED_INDEX_TOKEN).map(
+      (segment) => segment.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+    ).join(STRUCTURED_INDEX_TOKEN)
+  ).join(BLOCK_INDEX_TOKEN);
+}
 function isMarkdownEditorFieldType(fieldType) {
   return fieldType === "markdown" || fieldType === "mdxeditor" || fieldType === "easymde";
 }
@@ -5413,12 +5495,14 @@ function renderDynamicField(field, options = {}) {
 
           ${isMultiple ? `
             <div class="media-preview-grid grid grid-cols-4 gap-2 mb-2 ${mediaValues.length === 0 ? "hidden" : ""}" id="${fieldId}-preview">
-              ${mediaValues.map((url, idx) => `
+              ${mediaValues.map(
+        (url, idx) => `
                 <div class="relative media-preview-item" data-url="${url}">
                   ${renderMediaPreview(url, `Media ${idx + 1}`, "w-full h-24 object-cover rounded-lg border border-white/20")}
                   <button
                     type="button"
                     onclick="removeMediaFromMultiple('${fieldId}', '${url}')"
+                    data-media-remove="true"
                     class="absolute top-1 right-1 bg-red-600 text-white rounded-full p-1 hover:bg-red-700"
                     ${disabled ? "disabled" : ""}
                   >
@@ -5427,7 +5511,8 @@ function renderDynamicField(field, options = {}) {
                     </svg>
                   </button>
                 </div>
-              `).join("")}
+              `
+      ).join("")}
             </div>
           ` : `
             <div class="media-preview ${singleValue ? "" : "hidden"}" id="${fieldId}-preview">
@@ -5451,6 +5536,7 @@ function renderDynamicField(field, options = {}) {
               <button
                 type="button"
                 onclick="clearMediaField('${fieldId}')"
+                data-media-remove="true"
                 class="inline-flex items-center px-4 py-2 bg-red-600 text-white rounded-xl hover:bg-red-700 transition-all"
                 ${disabled ? "disabled" : ""}
               >
@@ -5484,7 +5570,7 @@ function renderDynamicField(field, options = {}) {
   }
   const showLabel = field.field_type !== "boolean";
   return `
-    <div class="form-group">
+    <div class="form-group" data-has-errors="${errors.length > 0 ? "true" : "false"}">
       ${showLabel ? `
       <label for="${fieldId}" class="block text-sm/6 font-medium text-zinc-950 dark:text-white mb-2">
         ${escapeHtml3(field.field_label)}
@@ -5493,7 +5579,7 @@ function renderDynamicField(field, options = {}) {
       ` : ""}
       ${fieldHTML}
       ${errors.length > 0 ? `
-        <div class="mt-2 text-sm text-pink-600 dark:text-pink-400">
+        <div class="mt-2 text-sm text-pink-600 dark:text-pink-400" data-validation-error-message>
           ${errors.map((error) => `<div>${escapeHtml3(error)}</div>`).join("")}
         </div>
       ` : ""}
@@ -5508,8 +5594,8 @@ function renderDynamicField(field, options = {}) {
 function renderFieldGroup(title, fields, collapsible = false) {
   const groupId = title.toLowerCase().replace(/\s+/g, "-");
   return `
-    <div class="field-group rounded-lg bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 mb-6">
-      <div class="field-group-header border-b border-zinc-950/5 dark:border-white/10 px-6 py-4 ${collapsible ? "cursor-pointer" : ""}" ${collapsible ? `onclick="toggleFieldGroup('${groupId}')"` : ""}>
+    <div class="field-group rounded-lg bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 mb-6" data-group-id="${escapeHtml3(groupId)}">
+      <div class="field-group-header border-b border-zinc-950/5 dark:border-white/10 px-6 py-4 ${collapsible ? "cursor-pointer" : ""}" ${collapsible ? `onclick="toggleFieldGroup(this)"` : ""}>
         <h3 class="text-base/7 font-semibold text-zinc-950 dark:text-white flex items-center">
           ${escapeHtml3(title)}
           ${collapsible ? `
@@ -5553,6 +5639,12 @@ function renderBlocksField(field, options, baseClasses, errorClasses) {
     >
       <input type="hidden" id="${fieldId}" name="${fieldName}" value="${escapeHtml3(JSON.stringify(blockValues))}">
 
+      <div class="flex items-center justify-between border-b border-zinc-950/5 dark:border-white/10 py-4">
+        <h3 class="text-base/7 font-semibold text-zinc-950 dark:text-white">
+          ${escapeHtml3(field.field_label || "Content Blocks")}
+        </h3>
+      </div>
+
       <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div class="flex-1">
           <select
@@ -5583,12 +5675,14 @@ function renderBlocksField(field, options, baseClasses, errorClasses) {
   `;
 }
 function renderStructuredObjectField(field, options, baseClasses, errorClasses) {
-  const { value = {}, pluginStatuses = {} } = options;
+  const { value = {}, pluginStatuses = {}, errors = [] } = options;
   const opts = field.field_options || {};
   const properties = opts.properties && typeof opts.properties === "object" ? opts.properties : {};
   const fieldId = `field-${field.field_name}`;
   const fieldName = field.field_name;
   const objectValue = normalizeStructuredObjectValue(value);
+  const objectLayout = opts.objectLayout || "nested";
+  const useNestedLayout = objectLayout !== "flat";
   const subfields = Object.entries(properties).map(
     ([propertyName, propertyConfig]) => renderStructuredSubfield(
       field,
@@ -5599,11 +5693,40 @@ function renderStructuredObjectField(field, options, baseClasses, errorClasses)
       field.field_name
     )
   ).join("");
+  const groupTitle = field.field_label || field.field_name;
+  if (!useNestedLayout) {
+    return `
+      <div class="space-y-4" data-structured-object data-field-name="${escapeHtml3(fieldName)}">
+        <input type="hidden" id="${fieldId}" name="${fieldName}" value="${escapeHtml3(JSON.stringify(objectValue))}">
+        <div class="flex items-center justify-between border-b border-zinc-950/5 dark:border-white/10 py-4 first-of-type:pt-0">
+          <h3 class="text-base/7 font-semibold text-zinc-950 dark:text-white">
+            ${escapeHtml3(groupTitle)}
+          </h3>
+        </div>
+        <div class="space-y-4" data-structured-object-fields>
+          ${subfields}
+        </div>
+      </div>
+      ${getStructuredFieldScript()}
+    `;
+  }
+  const groupId = sanitizeStructuredGroupId(field.field_name);
+  const isCollapsed = errors.length > 0 ? false : opts.collapsed !== false;
   return `
-    <div class="space-y-4" data-structured-object data-field-name="${escapeHtml3(fieldName)}">
-      <input type="hidden" id="${fieldId}" name="${fieldName}" value="${escapeHtml3(JSON.stringify(objectValue))}">
-      <div class="space-y-4" data-structured-object-fields>
-        ${subfields}
+    <div class="field-group rounded-lg shadow-sm mb-6" data-group-id="${escapeHtml3(groupId)}" data-structured-object data-field-name="${escapeHtml3(fieldName)}">
+      <div class="field-group-header border-b border-zinc-950/5 dark:border-white/10 pr-6 pb-4 cursor-pointer" onclick="toggleFieldGroup(this)">
+        <h3 class="text-base/7 font-semibold text-zinc-950 dark:text-white flex items-center">
+          ${escapeHtml3(groupTitle)}
+          <svg id="${groupId}-icon" class="w-5 h-5 ml-2 transform transition-transform ${isCollapsed ? "-rotate-90" : ""} text-zinc-500 dark:text-zinc-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path>
+          </svg>
+        </h3>
+      </div>
+      <div id="${groupId}-content" class="field-group-content px-6 py-6 space-y-4 ${isCollapsed ? "hidden" : ""}">
+        <input type="hidden" id="${fieldId}" name="${fieldName}" value="${escapeHtml3(JSON.stringify(objectValue))}">
+        <div class="space-y-4" data-structured-object-fields>
+          ${subfields}
+        </div>
       </div>
     </div>
     ${getStructuredFieldScript()}
@@ -5674,7 +5797,7 @@ function renderStructuredArrayField(field, options, baseClasses, errorClasses) {
 function renderStructuredArrayItem(field, itemConfig, index, itemValue, pluginStatuses, arrayItemTitle) {
   const itemFields = renderStructuredItemFields(field, itemConfig, index, itemValue, pluginStatuses);
   return `
-    <div class="structured-array-item rounded-lg border border-zinc-200 dark:border-white/10 bg-white/60 dark:bg-white/5 p-4 shadow-sm" data-array-index="${escapeHtml3(index)}" draggable="true">
+    <div class="structured-array-item rounded-lg border border-zinc-200 dark:border-white/10 bg-white/60 dark:bg-zinc-600/5 p-4 shadow-lg shadow-zinc-950/20" data-array-index="${escapeHtml3(index)}" draggable="true">
       <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div class="flex items-center gap-3">
           <div class="drag-handle cursor-move text-zinc-400 dark:text-zinc-500 hover:text-zinc-600 dark:hover:text-zinc-400" data-action="drag-handle" title="Drag to reorder">
@@ -5687,6 +5810,11 @@ function renderStructuredArrayItem(field, itemConfig, index, itemValue, pluginSt
           </div>
         </div>
         <div class="flex flex-wrap gap-2 text-xs">
+          <button type="button" data-action="toggle-item" class="inline-flex items-center justify-center rounded-md border border-zinc-200 px-2 py-1 text-zinc-600 hover:bg-zinc-100 dark:border-white/10 dark:text-zinc-300 dark:hover:bg-white/10" aria-label="Expand item" title="Expand">
+            <svg class="h-4 w-4 transition-transform -rotate-90 text-zinc-500 dark:text-zinc-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" data-item-toggle-icon>
+              <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7"></path>
+            </svg>
+          </button>
           <button type="button" data-action="move-up" class="inline-flex items-center justify-center rounded-md border border-zinc-200 px-2 py-1 text-zinc-600 hover:bg-zinc-100 dark:border-white/10 dark:text-zinc-300 dark:hover:bg-white/10 disabled:opacity-40 disabled:cursor-not-allowed disabled:hover:bg-transparent dark:disabled:hover:bg-transparent" aria-label="Move item up" title="Move up">
             <svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="4">
               <path stroke-linecap="round" stroke-linejoin="round" d="M12 6l-4 4m4-4l4 4m-4-4v12"/>
@@ -5705,7 +5833,7 @@ function renderStructuredArrayItem(field, itemConfig, index, itemValue, pluginSt
           </button>
         </div>
       </div>
-      <div class="mt-4 space-y-4" data-array-item-fields>
+      <div class="mt-4 space-y-4 hidden" data-array-item-fields>
         ${itemFields}
       </div>
     </div>
@@ -5815,7 +5943,7 @@ function normalizeBlocksValue(value, discriminator) {
 function renderBlockTemplate(field, block, discriminator, pluginStatuses) {
   return `
     <template data-block-template="${escapeHtml3(block.name)}">
-      ${renderBlockCard(field, block, discriminator, "__INDEX__", {}, pluginStatuses)}
+      ${renderBlockCard(field, block, discriminator, BLOCK_INDEX_TOKEN, {}, pluginStatuses)}
     </template>
   `;
 }
@@ -5857,7 +5985,7 @@ function renderBlockCard(field, block, discriminator, index, data, pluginStatuse
     `;
   }).join("");
   return `
-    <div class="blocks-item rounded-lg border border-zinc-200 dark:border-white/10 bg-white/60 dark:bg-white/5 p-4 shadow-sm" data-block-type="${escapeHtml3(block.name)}" data-block-discriminator="${escapeHtml3(discriminator)}" draggable="true">
+    <div class="blocks-item rounded-lg border border-zinc-200 dark:border-white/10 dark:bg-zinc-600/5 p-4 shadow-lg shadow-zinc-950/20" data-block-type="${escapeHtml3(block.name)}" data-block-discriminator="${escapeHtml3(discriminator)}" draggable="true">
       <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div class="flex items-start gap-3">
           <div class="drag-handle cursor-move text-zinc-400 dark:text-zinc-500 hover:text-zinc-600 dark:hover:text-zinc-400" data-action="drag-handle" title="Drag to reorder">
@@ -5865,7 +5993,7 @@ function renderBlockCard(field, block, discriminator, index, data, pluginStatuse
               <path stroke-linecap="round" stroke-linejoin="round" d="M4 8h16M4 16h16"/>
             </svg>
           </div>
-          <div>
+          <div class="cursor-pointer" data-action="toggle-block">
             <div class="text-sm font-semibold text-zinc-900 dark:text-white">
               ${escapeHtml3(block.label)}
               <span class="ml-2 text-xs font-normal text-zinc-500 dark:text-zinc-400" data-block-order-label></span>
@@ -5874,6 +6002,11 @@ function renderBlockCard(field, block, discriminator, index, data, pluginStatuse
           </div>
         </div>
         <div class="flex flex-wrap gap-2 text-xs">
+          <button type="button" data-action="toggle-block" class="inline-flex items-center justify-center rounded-md border border-zinc-200 px-2 py-1 text-zinc-600 hover:bg-zinc-100 dark:border-white/10 dark:text-zinc-300 dark:hover:bg-white/10" aria-label="Expand block" title="Expand">
+            <svg class="h-4 w-4 transition-transform -rotate-90 text-zinc-500 dark:text-zinc-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" data-block-toggle-icon>
+              <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7"></path>
+            </svg>
+          </button>
           <button type="button" data-action="move-up" class="inline-flex items-center justify-center rounded-md border border-zinc-200 px-2 py-1 text-zinc-600 hover:bg-zinc-100 dark:border-white/10 dark:text-zinc-300 dark:hover:bg-white/10 disabled:opacity-40 disabled:cursor-not-allowed disabled:hover:bg-transparent dark:disabled:hover:bg-transparent" aria-label="Move block up" title="Move up">
             <svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="4">
               <path stroke-linecap="round" stroke-linejoin="round" d="M12 6l-4 4m4-4l4 4m-4-4v12"/>
@@ -5892,7 +6025,7 @@ function renderBlockCard(field, block, discriminator, index, data, pluginStatuse
           </button>
         </div>
       </div>
-      <div class="mt-4 space-y-4">
+      <div class="mt-4 space-y-4 hidden" data-block-content>
         ${blockFields}
       </div>
     </div>
@@ -5926,9 +6059,101 @@ function getStructuredFieldScript() {
 
         function initializeStructuredFields() {
           const readFieldValue = window.sonicReadFieldValue;
+          const getDirectChild = (parent, selector) => {
+            if (!(parent instanceof Element)) return null;
+            return Array.from(parent.children).find(
+              (child) => child instanceof Element && child.matches(selector),
+            ) || null;
+          };
+          const getDirectStructuredSubfields = (host) =>
+            Array.from(host.children).filter(
+              (child) => child instanceof Element && child.classList.contains('structured-subfield'),
+            );
+          const getStructuredValueHost = (container) => {
+            const directObjectHost = getDirectChild(container, '[data-structured-object-fields]');
+            if (directObjectHost) return directObjectHost;
+            const groupContent = getDirectChild(container, '.field-group-content');
+            const nestedObjectHost = groupContent
+              ? getDirectChild(groupContent, '[data-structured-object-fields]')
+              : null;
+            if (nestedObjectHost) return nestedObjectHost;
+            return getDirectChild(container, '[data-array-item-fields]') || container;
+          };
+          const getCollectionScope = () => {
+            const url = new URL(window.location.href);
+            const collectionFromQuery = url.searchParams.get('collection');
+            const form = document.getElementById('content-form');
+            const collectionInput = form?.querySelector('input[name="collection_id"]');
+            const collectionFromForm = collectionInput instanceof HTMLInputElement ? collectionInput.value : '';
+            const collectionId = collectionFromQuery || collectionFromForm || '';
+            return window.location.pathname + ':' + collectionId;
+          };
+
+          const getArrayStateKey = (container) => {
+            const fieldName = container.dataset.fieldName || 'unknown';
+            return 'sonic:ui:repeaters:' + getCollectionScope() + ':' + fieldName;
+          };
+
+          const readArrayState = (container) => {
+            try {
+              const raw = sessionStorage.getItem(getArrayStateKey(container));
+              if (!raw) return null;
+              const parsed = JSON.parse(raw);
+              return Array.isArray(parsed) ? parsed : null;
+            } catch {
+              return null;
+            }
+          };
+
+          const writeArrayState = (container, state) => {
+            try {
+              sessionStorage.setItem(getArrayStateKey(container), JSON.stringify(state));
+            } catch {}
+          };
+
+          const setArrayItemExpanded = (item, isExpanded) => {
+            const content = item.querySelector('[data-array-item-fields]');
+            const icon = item.querySelector('[data-item-toggle-icon]');
+            if (content instanceof HTMLElement) {
+              content.classList.toggle('hidden', !isExpanded);
+            }
+            if (icon instanceof Element) {
+              icon.classList.toggle('-rotate-90', !isExpanded);
+            }
+          };
+
+          const getArrayItems = (container, list) => {
+            if (list) {
+              return Array.from(list.querySelectorAll(':scope > .structured-array-item'));
+            }
+            return Array.from(
+              container.querySelectorAll(':scope > [data-structured-array-list] > .structured-array-item'),
+            );
+          };
+
+          const captureArrayState = (container) => {
+            return getArrayItems(container).map((item) => {
+              const content = item.querySelector('[data-array-item-fields]');
+              return content instanceof HTMLElement ? !content.classList.contains('hidden') : false;
+            });
+          };
+
+          const applyArrayState = (container, state) => {
+            const items = getArrayItems(container);
+            items.forEach((item, index) => {
+              if (typeof state[index] === 'boolean') {
+                setArrayItemExpanded(item, state[index]);
+              }
+            });
+          };
+
+          const syncArrayState = (container) => {
+            writeArrayState(container, captureArrayState(container));
+          };
 
           const readStructuredValue = (container) => {
-            const fields = Array.from(container.querySelectorAll('.structured-subfield'));
+            const fieldHost = getStructuredValueHost(container);
+            const fields = getDirectStructuredSubfields(fieldHost);
             if (fields.length === 1 && fields[0].dataset.structuredField === '__value') {
               return readFieldValue(fields[0]);
             }
@@ -5942,111 +6167,229 @@ function getStructuredFieldScript() {
           };
 
           document.querySelectorAll('[data-structured-object]').forEach((container) => {
+            if (container.closest('template')) {
+              return;
+            }
             if (container.dataset.structuredInitialized === 'true') {
               return;
             }
-            container.dataset.structuredInitialized = 'true';
-            const hiddenInput = container.querySelector('input[type="hidden"]');
+            if (container.dataset.structuredInitializing === 'true') {
+              return;
+            }
+            container.dataset.structuredInitializing = 'true';
+            try {
+              const hiddenInput = container.querySelector('input[type="hidden"]');
 
-            const updateHiddenInput = () => {
-              if (!hiddenInput) return;
-              const value = readStructuredValue(container);
-              hiddenInput.value = JSON.stringify(value);
-            };
+              const updateHiddenInput = () => {
+                if (!hiddenInput) return;
+                const value = readStructuredValue(container);
+                hiddenInput.value = JSON.stringify(value);
+              };
 
-            container.addEventListener('input', updateHiddenInput);
-            container.addEventListener('change', updateHiddenInput);
-            updateHiddenInput();
+              container.addEventListener('input', updateHiddenInput);
+              container.addEventListener('change', updateHiddenInput);
+              updateHiddenInput();
+              container.dataset.structuredInitialized = 'true';
+            } catch (error) {
+              delete container.dataset.structuredInitialized;
+              console.error('[structured-object] initialization failed', error);
+            } finally {
+              delete container.dataset.structuredInitializing;
+            }
           });
 
           document.querySelectorAll('[data-structured-array]').forEach((container) => {
+            if (container.closest('template')) {
+              return;
+            }
             if (container.dataset.structuredInitialized === 'true') {
               return;
             }
-            container.dataset.structuredInitialized = 'true';
-            const list = container.querySelector('[data-structured-array-list]');
-            const hiddenInput = container.querySelector('input[type="hidden"]');
-            const template = container.querySelector('template[data-structured-array-template]');
+            if (container.dataset.structuredInitializing === 'true') {
+              return;
+            }
+            container.dataset.structuredInitializing = 'true';
+            try {
+              const list = container.querySelector(':scope > [data-structured-array-list]');
+              const hiddenInput = container.querySelector(':scope > input[type="hidden"]');
+              const template = container.querySelector(':scope > template[data-structured-array-template]');
+              if (
+                template instanceof HTMLTemplateElement &&
+                typeof template.innerHTML === 'string' &&
+                template.innerHTML.trim()
+              ) {
+                container.__sonicStructuredArrayTemplate = template.innerHTML;
+              }
 
-            const updateOrderLabels = () => {
-              const items = Array.from(container.querySelectorAll('.structured-array-item'));
-              items.forEach((item, index) => {
-                const label = item.querySelector('[data-array-order-label]');
-                if (label) {
-                  label.textContent = '#'+ (index + 1);
+              const getLiveList = () =>
+                list || container.querySelector(':scope > [data-structured-array-list]');
+              const getLiveHiddenInput = () =>
+                hiddenInput || container.querySelector(':scope > input[type="hidden"]');
+              const getTemplateHtml = () => {
+                if (typeof container.__sonicStructuredArrayTemplate === 'string' &&
+                    container.__sonicStructuredArrayTemplate.trim()) {
+                  return container.__sonicStructuredArrayTemplate;
                 }
 
-                const moveUpButton = item.querySelector('[data-action="move-up"]');
-                if (moveUpButton instanceof HTMLButtonElement) {
-                  moveUpButton.disabled = index === 0;
+                const liveTemplate =
+                  template instanceof HTMLTemplateElement
+                    ? template
+                    : container.querySelector(':scope > template[data-structured-array-template]');
+                if (
+                  liveTemplate instanceof HTMLTemplateElement &&
+                  typeof liveTemplate.innerHTML === 'string' &&
+                  liveTemplate.innerHTML.trim()
+                ) {
+                  container.__sonicStructuredArrayTemplate = liveTemplate.innerHTML;
+                  return liveTemplate.innerHTML;
                 }
+                return typeof container.__sonicStructuredArrayTemplate === 'string'
+                  ? container.__sonicStructuredArrayTemplate
+                  : '';
+              };
 
-                const moveDownButton = item.querySelector('[data-action="move-down"]');
-                if (moveDownButton instanceof HTMLButtonElement) {
-                  moveDownButton.disabled = index === items.length - 1;
+              const updateOrderLabels = () => {
+                const liveList = getLiveList();
+                if (!liveList) return;
+                const items = getArrayItems(container, liveList);
+                items.forEach((item, index) => {
+                  const label = item.querySelector('[data-array-order-label]');
+                  if (label) {
+                    label.textContent = '#'+ (index + 1);
+                  }
+
+                  const moveUpButton = item.querySelector('[data-action="move-up"]');
+                  if (moveUpButton instanceof HTMLButtonElement) {
+                    moveUpButton.disabled = index === 0;
+                  }
+
+                  const moveDownButton = item.querySelector('[data-action="move-down"]');
+                  if (moveDownButton instanceof HTMLButtonElement) {
+                    moveDownButton.disabled = index === items.length - 1;
+                  }
+                });
+              };
+
+              const updateHiddenInput = () => {
+                const liveHiddenInput = getLiveHiddenInput();
+                const liveList = getLiveList();
+                if (!liveHiddenInput || !liveList) return;
+                const items = getArrayItems(container, liveList);
+                const values = items.map((item) => readStructuredValue(item));
+                liveHiddenInput.value = JSON.stringify(values);
+                // Notify parent structured containers after non-input actions (add/remove/move)
+                // so nested array mutations are persisted correctly.
+                liveHiddenInput.dispatchEvent(new Event('change', { bubbles: true }));
+
+                const emptyState = liveList.querySelector(':scope > [data-structured-empty]');
+                if (emptyState) {
+                  emptyState.style.display = values.length === 0 ? 'block' : 'none';
                 }
-              });
-            };
+                updateOrderLabels();
+              };
 
-            const updateHiddenInput = () => {
-              if (!hiddenInput || !list) return;
-              const items = Array.from(list.querySelectorAll('.structured-array-item'));
-              const values = items.map((item) => readStructuredValue(item));
-              hiddenInput.value = JSON.stringify(values);
+              const addArrayItem = () => {
+                const liveList = getLiveList();
+                if (!liveList) return;
+                const templateHtml = getTemplateHtml();
+                if (!templateHtml) return;
+                try {
+                  const nextIndex = getArrayItems(container, liveList).length;
+                  const html = templateHtml.replace(/__INDEX__/g, String(nextIndex));
+                  liveList.insertAdjacentHTML('beforeend', html);
+                  const newItem = liveList.lastElementChild;
+                  if (newItem instanceof HTMLElement) {
+                    // Ensure cloned template content can be initialized even if stale
+                    // data-structured-initialized attributes were copied.
+                    newItem
+                      .querySelectorAll('[data-structured-object], [data-structured-array]')
+                      .forEach((nestedContainer) => {
+                        if (nestedContainer instanceof HTMLElement) {
+                          delete nestedContainer.dataset.structuredInitialized;
+                        }
+                      });
+                    setArrayItemExpanded(newItem, true);
+                  }
+                  if (typeof initializeTinyMCE === 'function') {
+                    initializeTinyMCE();
+                  }
+                  if (typeof window.initializeQuillEditors === 'function') {
+                    window.initializeQuillEditors();
+                  }
+                  if (typeof initializeMDXEditor === 'function') {
+                    initializeMDXEditor();
+                  }
+                  if (typeof window.initializeStructuredFields === 'function') {
+                    window.initializeStructuredFields();
+                  }
+                  updateHiddenInput();
+                  syncArrayState(container);
+                } catch (error) {
+                  console.error('[structured-array] add-item failed', error);
+                }
+              };
 
-              const emptyState = list.querySelector('[data-structured-empty]');
-              if (emptyState) {
-                emptyState.style.display = values.length === 0 ? 'block' : 'none';
+              const topLevelAddButton = container.querySelector(
+                ':scope > .flex.items-center.justify-between.gap-3 [data-action="add-item"]',
+              );
+              if (topLevelAddButton instanceof HTMLElement) {
+                topLevelAddButton.addEventListener('click', (event) => {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  addArrayItem();
+                });
               }
-              updateOrderLabels();
-            };
 
-            if (typeof window.initializeDragSortable === 'function' && list) {
-              window.initializeDragSortable(list, {
-                itemSelector: '.structured-array-item',
-                handleSelector: '[data-action="drag-handle"]',
-                onUpdate: updateHiddenInput
-              });
-            }
+              const dragList = getLiveList();
+              if (typeof window.initializeDragSortable === 'function' && dragList) {
+                window.initializeDragSortable(dragList, {
+                  itemSelector: '.structured-array-item',
+                  handleSelector: '[data-action="drag-handle"]',
+                  onUpdate: () => {
+                    updateHiddenInput();
+                    syncArrayState(container);
+                  }
+                });
+              }
 
-            container.addEventListener('click', (event) => {
+              container.addEventListener('click', (event) => {
               const target = event.target;
               if (!(target instanceof Element)) return;
               const actionButton = target.closest('[data-action]');
               if (!actionButton || actionButton.hasAttribute('disabled')) return;
+              const actionOwner = actionButton.closest('[data-structured-array]');
+              if (actionOwner !== container) return;
 
-              const action = actionButton.getAttribute('data-action');
+                const action = actionButton.getAttribute('data-action');
 
-              if (action === 'add-item') {
-                if (!list || !template) return;
-                const nextIndex = list.querySelectorAll('.structured-array-item').length;
-                const html = template.innerHTML.replace(/__INDEX__/g, String(nextIndex));
-                list.insertAdjacentHTML('beforeend', html);
-                if (typeof initializeTinyMCE === 'function') {
-                  initializeTinyMCE();
-                }
-                if (typeof window.initializeQuillEditors === 'function') {
-                  window.initializeQuillEditors();
-                }
-                if (typeof initializeMDXEditor === 'function') {
-                  initializeMDXEditor();
+                if (action === 'add-item') {
+                  addArrayItem();
+                  return;
                 }
-                updateHiddenInput();
-                return;
-              }
 
               const item = actionButton.closest('.structured-array-item');
-              if (!item || !list) return;
+              const liveList = getLiveList();
+              if (!item || !liveList) return;
+
+              if (action === 'toggle-item') {
+                const content = item.querySelector('[data-array-item-fields]');
+                if (!(content instanceof HTMLElement)) return;
+                setArrayItemExpanded(item, content.classList.contains('hidden'));
+                syncArrayState(container);
+                return;
+              }
 
               if (action === 'remove-item') {
                 if (typeof requestRepeaterDelete === 'function') {
                   requestRepeaterDelete(() => {
                     item.remove();
                     updateHiddenInput();
+                    syncArrayState(container);
                   });
                 } else {
                   item.remove();
                   updateHiddenInput();
+                  syncArrayState(container);
                 }
                 return;
               }
@@ -6054,8 +6397,9 @@ function getStructuredFieldScript() {
               if (action === 'move-up') {
                 const previous = item.previousElementSibling;
                 if (previous) {
-                  list.insertBefore(item, previous);
+                  liveList.insertBefore(item, previous);
                   updateHiddenInput();
+                  syncArrayState(container);
                 }
                 return;
               }
@@ -6063,29 +6407,43 @@ function getStructuredFieldScript() {
               if (action === 'move-down') {
                 const next = item.nextElementSibling;
                 if (next) {
-                  list.insertBefore(next, item);
+                  liveList.insertBefore(next, item);
                   updateHiddenInput();
+                  syncArrayState(container);
                 }
               }
-            });
+              });
 
-            container.addEventListener('input', (event) => {
+              container.addEventListener('input', (event) => {
               const target = event.target;
               if (!(target instanceof Element)) return;
               if (target.closest('[data-structured-array-list]')) {
                 updateHiddenInput();
               }
-            });
+              });
 
-            container.addEventListener('change', (event) => {
+              container.addEventListener('change', (event) => {
               const target = event.target;
               if (!(target instanceof Element)) return;
               if (target.closest('[data-structured-array-list]')) {
                 updateHiddenInput();
               }
-            });
+              });
 
-            updateHiddenInput();
+              updateHiddenInput();
+              const savedArrayState = readArrayState(container);
+              if (savedArrayState) {
+                applyArrayState(container, savedArrayState);
+              } else {
+                syncArrayState(container);
+              }
+              container.dataset.structuredInitialized = 'true';
+            } catch (error) {
+              delete container.dataset.structuredInitialized;
+              console.error('[structured-array] initialization failed', error);
+            } finally {
+              delete container.dataset.structuredInitializing;
+            }
           });
         }
 
@@ -6100,7 +6458,10 @@ function getStructuredFieldScript() {
         document.addEventListener('htmx:afterSwap', function() {
           setTimeout(initializeStructuredFields, 50);
         });
-      } else if (typeof window.initializeStructuredFields === 'function') {
+      } else if (
+        typeof window.initializeStructuredFields === 'function' &&
+        document.readyState !== 'loading'
+      ) {
         window.initializeStructuredFields();
       }
     </script>
@@ -6112,6 +6473,68 @@ function getBlocksFieldScript() {
     <script>
       if (!window.__sonicBlocksFieldInit) {
         window.__sonicBlocksFieldInit = true;
+        const getCollectionScope = () => {
+          const url = new URL(window.location.href);
+          const collectionFromQuery = url.searchParams.get('collection');
+          const form = document.getElementById('content-form');
+          const collectionInput = form?.querySelector('input[name="collection_id"]');
+          const collectionFromForm = collectionInput instanceof HTMLInputElement ? collectionInput.value : '';
+          const collectionId = collectionFromQuery || collectionFromForm || '';
+          return window.location.pathname + ':' + collectionId;
+        };
+
+        const getBlocksStateKey = (container) => {
+          const fieldName = container.dataset.fieldName || 'unknown';
+          return 'sonic:ui:blocks:' + getCollectionScope() + ':' + fieldName;
+        };
+
+        const readBlocksState = (container) => {
+          try {
+            const raw = sessionStorage.getItem(getBlocksStateKey(container));
+            if (!raw) return null;
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : null;
+          } catch {
+            return null;
+          }
+        };
+
+        const writeBlocksState = (container, state) => {
+          try {
+            sessionStorage.setItem(getBlocksStateKey(container), JSON.stringify(state));
+          } catch {}
+        };
+
+        const setBlockExpanded = (item, isExpanded) => {
+          const content = item.querySelector('[data-block-content]');
+          const icon = item.querySelector('[data-block-toggle-icon]');
+          if (content instanceof HTMLElement) {
+            content.classList.toggle('hidden', !isExpanded);
+          }
+          if (icon instanceof Element) {
+            icon.classList.toggle('-rotate-90', !isExpanded);
+          }
+        };
+
+        const captureBlocksState = (container) => {
+          return Array.from(container.querySelectorAll('.blocks-item')).map((item) => {
+            const content = item.querySelector('[data-block-content]');
+            return content instanceof HTMLElement ? !content.classList.contains('hidden') : false;
+          });
+        };
+
+        const applyBlocksState = (container, state) => {
+          const items = Array.from(container.querySelectorAll('.blocks-item'));
+          items.forEach((item, index) => {
+            if (typeof state[index] === 'boolean') {
+              setBlockExpanded(item, state[index]);
+            }
+          });
+        };
+
+        const syncBlocksState = (container) => {
+          writeBlocksState(container, captureBlocksState(container));
+        };
 
         function initializeBlocksFields() {
           document.querySelectorAll('.blocks-field').forEach((container) => {
@@ -6199,7 +6622,10 @@ function getBlocksFieldScript() {
               window.initializeDragSortable(list, {
                 itemSelector: '.blocks-item',
                 handleSelector: '[data-action="drag-handle"]',
-                onUpdate: updateHiddenInput
+                onUpdate: () => {
+                  updateHiddenInput();
+                  syncBlocksState(container);
+                }
               });
             }
 
@@ -6221,8 +6647,12 @@ function getBlocksFieldScript() {
                 if (!template) return;
 
                 const nextIndex = list.querySelectorAll('.blocks-item').length;
-                const html = template.innerHTML.replace(/__INDEX__/g, String(nextIndex));
+                const html = template.innerHTML.replace(/__BLOCK_INDEX__/g, String(nextIndex));
                 list.insertAdjacentHTML('beforeend', html);
+                const newItem = list.lastElementChild;
+                if (newItem instanceof HTMLElement) {
+                  setBlockExpanded(newItem, true);
+                }
                 if (typeSelect) {
                   typeSelect.value = '';
                 }
@@ -6231,21 +6661,32 @@ function getBlocksFieldScript() {
                   window.initializeStructuredFields();
                 }
                 updateHiddenInput();
+                syncBlocksState(container);
                 return;
               }
 
               const item = actionButton.closest('.blocks-item');
               if (!item || !list) return;
 
+              if (action === 'toggle-block') {
+                const content = item.querySelector('[data-block-content]');
+                if (!(content instanceof HTMLElement)) return;
+                setBlockExpanded(item, content.classList.contains('hidden'));
+                syncBlocksState(container);
+                return;
+              }
+
               if (action === 'remove-block') {
                 if (typeof requestRepeaterDelete === 'function') {
                   requestRepeaterDelete(() => {
                     item.remove();
                     updateHiddenInput();
+                    syncBlocksState(container);
                   }, 'block');
                 } else {
                   item.remove();
                   updateHiddenInput();
+                  syncBlocksState(container);
                 }
                 return;
               }
@@ -6255,6 +6696,7 @@ function getBlocksFieldScript() {
                 if (previous) {
                   list.insertBefore(item, previous);
                   updateHiddenInput();
+                  syncBlocksState(container);
                 }
                 return;
               }
@@ -6264,6 +6706,7 @@ function getBlocksFieldScript() {
                 if (next) {
                   list.insertBefore(next, item);
                   updateHiddenInput();
+                  syncBlocksState(container);
                 }
               }
             });
@@ -6285,6 +6728,12 @@ function getBlocksFieldScript() {
             });
 
             updateHiddenInput();
+            const savedBlocksState = readBlocksState(container);
+            if (savedBlocksState) {
+              applyBlocksState(container, savedBlocksState);
+            } else {
+              syncBlocksState(container);
+            }
           });
         }
 
@@ -6321,6 +6770,7 @@ init_admin_layout_catalyst_template();
 function renderContentFormPage(data) {
   const isEdit = data.isEdit || !!data.id;
   const title = isEdit ? `Edit: ${data.title || "Content"}` : `New ${data.collection.display_name}`;
+  const hasValidationErrors = Boolean(data.validationErrors && Object.keys(data.validationErrors).length > 0);
   const backUrl = data.referrerParams ? `/admin/content?${data.referrerParams}` : `/admin/content?collection=${data.collection.id}`;
   const coreFields = data.fields.filter((f) => ["title", "slug", "content"].includes(f.field_name));
   const contentFields = data.fields.filter((f) => !["title", "slug", "content"].includes(f.field_name) && !f.field_name.startsWith("meta_"));
@@ -6409,6 +6859,7 @@ function renderContentFormPage(data) {
             ${isEdit ? `hx-put="/admin/content/${data.id}"` : `hx-post="/admin/content"`}
             hx-target="#form-messages"
             hx-encoding="multipart/form-data"
+            data-has-validation-errors="${hasValidationErrors ? "true" : "false"}"
             class="space-y-6"
           >
             <input type="hidden" name="collection_id" value="${data.collection.id}">
@@ -6689,39 +7140,456 @@ function renderContentFormPage(data) {
 
     <!-- Dynamic Field Scripts -->
     <script>
+      const contentFormCollectionId = ${JSON.stringify(data.collection.id)};
+
+      function getFieldGroupScope() {
+        const url = new URL(window.location.href);
+        const urlCollectionId = url.searchParams.get('collection');
+        const effectiveCollectionId = urlCollectionId || contentFormCollectionId || '';
+        return window.location.pathname + ':' + effectiveCollectionId;
+      }
+
+      function getItemPosition(itemSelector, item) {
+        if (!(item instanceof Element)) return -1;
+        const parent = item.parentElement;
+        if (!parent) return -1;
+        return Array.from(parent.querySelectorAll(':scope > ' + itemSelector)).indexOf(item);
+      }
+
+      function stripIndexedFieldPrefix(fullFieldName, prefix) {
+        if (!fullFieldName || !prefix || !fullFieldName.startsWith(prefix)) {
+          return fullFieldName;
+        }
+
+        const remainder = fullFieldName.slice(prefix.length);
+        const indexMatch = remainder.match(/^(\\d+)(-|__)(.*)$/);
+        if (!indexMatch) {
+          return fullFieldName;
+        }
+
+        return indexMatch[3];
+      }
+
+      function getFieldGroupStorageKey(groupOrId) {
+        const defaultGroupId = typeof groupOrId === 'string' ? groupOrId : (groupOrId?.getAttribute('data-group-id') || 'unknown');
+        const group = typeof groupOrId === 'string'
+          ? document.querySelector('.field-group[data-group-id="' + defaultGroupId + '"]')
+          : groupOrId;
+
+        const scopePrefix = 'sonic:ui:objects:' + getFieldGroupScope() + ':';
+        if (!(group instanceof Element)) {
+          return scopePrefix + defaultGroupId;
+        }
+
+        const fullFieldName = group.getAttribute('data-field-name') || '';
+
+        const blocksField = group.closest('.blocks-field');
+        const blockItem = group.closest('.blocks-item');
+        if (blocksField instanceof Element && blockItem instanceof Element) {
+          const blocksFieldName = blocksField.getAttribute('data-field-name') || 'unknown';
+          const blockPosition = getItemPosition('.blocks-item', blockItem);
+          const relativePath = stripIndexedFieldPrefix(fullFieldName, 'block-' + blocksFieldName + '-') || defaultGroupId;
+          return scopePrefix + 'blocks:' + blocksFieldName + ':' + blockPosition + ':' + relativePath;
+        }
+
+        const arrayField = group.closest('[data-structured-array][data-field-name]');
+        const arrayItem = group.closest('.structured-array-item');
+        if (arrayField instanceof Element && arrayItem instanceof Element) {
+          const arrayFieldName = arrayField.getAttribute('data-field-name') || 'unknown';
+          const itemPosition = getItemPosition('.structured-array-item', arrayItem);
+          const relativePath = stripIndexedFieldPrefix(fullFieldName, 'array-' + arrayFieldName + '-') || defaultGroupId;
+          return scopePrefix + 'repeaters:' + arrayFieldName + ':' + itemPosition + ':' + relativePath;
+        }
+
+        return scopePrefix + defaultGroupId;
+      }
+
+      function loadFieldGroupState(group) {
+        try {
+          const value = sessionStorage.getItem(getFieldGroupStorageKey(group));
+          if (value === '1') return true;
+          if (value === '0') return false;
+        } catch {}
+        return null;
+      }
+
+      function saveFieldGroupState(group, isCollapsed) {
+        try {
+          sessionStorage.setItem(getFieldGroupStorageKey(group), isCollapsed ? '1' : '0');
+        } catch {}
+      }
+
+      function resolveFieldGroupElements(groupOrId) {
+        let group = null;
+
+        if (groupOrId instanceof Element) {
+          group = groupOrId.classList.contains('field-group')
+            ? groupOrId
+            : groupOrId.closest('.field-group[data-group-id]');
+        } else if (typeof groupOrId === 'string' && groupOrId) {
+          group = document.querySelector('.field-group[data-group-id="' + groupOrId + '"]');
+        }
+
+        let content = null;
+        let icon = null;
+
+        if (group instanceof Element) {
+          content = group.querySelector(':scope > .field-group-content');
+          icon = group.querySelector(':scope > .field-group-header svg[id$="-icon"]');
+        }
+
+        // Legacy fallback for any existing calls still passing string IDs.
+        if (!(content instanceof HTMLElement) && typeof groupOrId === 'string') {
+          content = document.getElementById(groupOrId + '-content');
+        }
+        if (!(icon instanceof Element) && typeof groupOrId === 'string') {
+          icon = document.getElementById(groupOrId + '-icon');
+        }
+
+        if (!(group instanceof Element) && content instanceof Element) {
+          group = content.closest('.field-group[data-group-id]');
+        }
+
+        return { group, content, icon };
+      }
+
+      function applyFieldGroupState(groupOrId, isCollapsed) {
+        const { content, icon } = resolveFieldGroupElements(groupOrId);
+        if (!(content instanceof HTMLElement) || !(icon instanceof Element)) return;
+        content.classList.toggle('hidden', isCollapsed);
+        icon.classList.toggle('-rotate-90', isCollapsed);
+      }
+
+      function restoreFieldGroupStates() {
+        document.querySelectorAll('.field-group[data-group-id]').forEach((group) => {
+          const savedState = loadFieldGroupState(group);
+          if (savedState === null) return;
+          applyFieldGroupState(group, savedState);
+        });
+      }
+
+      function persistAllFieldGroupStates() {
+        document.querySelectorAll('.field-group[data-group-id]').forEach((group) => {
+          const { content } = resolveFieldGroupElements(group);
+          if (!(content instanceof HTMLElement)) return;
+          saveFieldGroupState(group, content.classList.contains('hidden'));
+        });
+      }
+
+      function setValidationHeaderIndicator(container) {
+        if (!(container instanceof Element)) return;
+        let header = null;
+        let markerTarget = null;
+
+        if (container.classList.contains('field-group')) {
+          header = container.querySelector(':scope > .field-group-header');
+          markerTarget = container.querySelector(':scope > .field-group-header h3');
+        } else if (container.classList.contains('structured-array-item')) {
+          header = container.querySelector('[data-action="toggle-item"]');
+          markerTarget = header;
+        } else if (container.classList.contains('blocks-item')) {
+          header = container.querySelector('[data-action="toggle-block"]');
+          markerTarget = header;
+        }
+
+        if (!(header instanceof HTMLElement)) return;
+        if (!(markerTarget instanceof HTMLElement)) {
+          markerTarget = header;
+        }
+
+        header.dataset.validationHeaderError = 'true';
+        header.classList.add('text-pink-700', 'dark:text-pink-300');
+
+        if (!markerTarget.querySelector('[data-validation-indicator]')) {
+          const marker = document.createElement('span');
+          marker.setAttribute('data-validation-indicator', 'true');
+          marker.className = 'ml-2 inline-block h-2 w-2 rounded-full bg-pink-500 align-middle';
+          marker.setAttribute('aria-hidden', 'true');
+          markerTarget.appendChild(marker);
+        }
+      }
+
+      function clearValidationIndicators() {
+        document.querySelectorAll('[data-validation-header-error="true"]').forEach((el) => {
+          if (!(el instanceof HTMLElement)) return;
+          delete el.dataset.validationHeaderError;
+          el.classList.remove('text-pink-700', 'dark:text-pink-300');
+        });
+
+        document.querySelectorAll('[data-validation-indicator]').forEach((el) => el.remove());
+      }
+
+      function expandContainerForValidation(container) {
+        if (!(container instanceof Element)) return;
+
+        if (container.classList.contains('field-group')) {
+          applyFieldGroupState(container, false);
+          return;
+        }
+
+        if (container.classList.contains('structured-array-item')) {
+          const content = container.querySelector('[data-array-item-fields]');
+          const icon = container.querySelector('[data-item-toggle-icon]');
+          if (content instanceof HTMLElement) {
+            content.classList.remove('hidden');
+          }
+          if (icon instanceof Element) {
+            icon.classList.remove('-rotate-90');
+          }
+          return;
+        }
+
+        if (container.classList.contains('blocks-item')) {
+          const content = container.querySelector('[data-block-content]');
+          const icon = container.querySelector('[data-block-toggle-icon]');
+          if (content instanceof HTMLElement) {
+            content.classList.remove('hidden');
+          }
+          if (icon instanceof Element) {
+            icon.classList.remove('-rotate-90');
+          }
+        }
+      }
+
+      function walkErrorContainers(node, expand) {
+        if (!(node instanceof Element)) return;
+        const visited = new Set();
+        let cursor = node;
+        while (cursor) {
+          const candidates = [
+            cursor.closest('.structured-array-item'),
+            cursor.closest('.blocks-item'),
+            cursor.closest('.field-group[data-group-id]')
+          ].filter((c) => c instanceof Element && !visited.has(c));
+
+          if (candidates.length === 0) break;
+
+          // Pick nearest ancestor container to preserve "first-error path only".
+          let nearest = candidates[0];
+          let bestDistance = Number.MAX_SAFE_INTEGER;
+          for (const candidate of candidates) {
+            let distance = 0;
+            let walker = cursor;
+            while (walker && walker !== candidate) {
+              walker = walker.parentElement;
+              distance += 1;
+            }
+            if (distance < bestDistance) {
+              bestDistance = distance;
+              nearest = candidate;
+            }
+          }
+
+          visited.add(nearest);
+          setValidationHeaderIndicator(nearest);
+          if (expand) {
+            expandContainerForValidation(nearest);
+          }
+          cursor = nearest.parentElement;
+        }
+      }
+
+      function getFocusableTargetFromErrorGroup(group) {
+        if (!(group instanceof Element)) return null;
+        return (
+          group.querySelector('input:not([type="hidden"]):not([disabled]), textarea:not([disabled]), select:not([disabled]), [contenteditable="true"]') ||
+          group.querySelector('button:not([disabled])')
+        );
+      }
+
+      function revealServerValidationErrors() {
+        clearValidationIndicators();
+
+        const errorGroups = Array.from(document.querySelectorAll('.form-group[data-has-errors="true"]'));
+        if (errorGroups.length === 0) return;
+
+        // Add indicators for all errored sections, expand only first-error path.
+        errorGroups.forEach((group, index) => {
+          walkErrorContainers(group, index === 0);
+        });
+
+        const firstTarget = getFocusableTargetFromErrorGroup(errorGroups[0]);
+        if (firstTarget instanceof HTMLElement) {
+          firstTarget.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          firstTarget.focus({ preventScroll: true });
+        }
+      }
+
+      function revealNativeValidationErrors(form) {
+        if (!(form instanceof HTMLFormElement)) return;
+        clearValidationIndicators();
+
+        const invalidControls = Array.from(form.querySelectorAll(':invalid'));
+        if (invalidControls.length === 0) return;
+
+        invalidControls.forEach((control, index) => {
+          walkErrorContainers(control, index === 0);
+        });
+
+        const first = invalidControls[0];
+        if (first instanceof HTMLElement) {
+          first.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          first.focus({ preventScroll: true });
+        }
+      }
+
       // Field group toggle
-      function toggleFieldGroup(groupId) {
-        const content = document.getElementById(groupId + '-content');
-        const icon = document.getElementById(groupId + '-icon');
-        
-        if (content.classList.contains('hidden')) {
-          content.classList.remove('hidden');
-          icon.classList.remove('rotate-[-90deg]');
-        } else {
-          content.classList.add('hidden');
-          icon.classList.add('rotate-[-90deg]');
+      function toggleFieldGroup(groupOrTrigger) {
+        const { group, content } = resolveFieldGroupElements(groupOrTrigger);
+        if (!(group instanceof Element)) return;
+        if (!(content instanceof HTMLElement)) return;
+
+        const isCollapsed = !content.classList.contains('hidden');
+        applyFieldGroupState(group, isCollapsed);
+        saveFieldGroupState(group, isCollapsed);
+      }
+
+      if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => {
+          restoreFieldGroupStates();
+          const form = document.getElementById('content-form');
+          if (form?.getAttribute('data-has-validation-errors') === 'true') {
+            revealServerValidationErrors();
+          }
+        });
+      } else {
+        restoreFieldGroupStates();
+        const form = document.getElementById('content-form');
+        if (form?.getAttribute('data-has-validation-errors') === 'true') {
+          revealServerValidationErrors();
         }
       }
 
+      document.addEventListener('htmx:afterSwap', function() {
+        setTimeout(() => {
+          restoreFieldGroupStates();
+          const form = document.getElementById('content-form');
+          if (form?.getAttribute('data-has-validation-errors') === 'true') {
+            revealServerValidationErrors();
+          }
+        }, 50);
+      });
+
+      const contentFormEl = document.getElementById('content-form');
+      if (contentFormEl instanceof HTMLFormElement) {
+        contentFormEl.addEventListener('submit', () => {
+          persistAllFieldGroupStates();
+        }, true);
+      }
+
+      window.addEventListener('beforeunload', () => {
+        persistAllFieldGroupStates();
+      });
+
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+          persistAllFieldGroupStates();
+        }
+      });
+
+      let pendingNativeValidationReveal = false;
+      document.addEventListener('invalid', function(event) {
+        const target = event.target;
+        if (!(target instanceof Element)) return;
+        const form = target.closest('form');
+        if (!(form instanceof HTMLFormElement)) return;
+
+        if (pendingNativeValidationReveal) return;
+        pendingNativeValidationReveal = true;
+
+        // Expand only first invalid path synchronously so the browser can focus it
+        // and avoid "invalid form control is not focusable" errors.
+        walkErrorContainers(target, true);
+
+        setTimeout(() => {
+          pendingNativeValidationReveal = false;
+          revealNativeValidationErrors(form);
+        }, 0);
+      }, true);
+
       // Media field functions
-      let currentMediaFieldId = null;
+      function notifyFieldChange(input) {
+        if (!input) return;
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        input.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+
+      function getActiveMediaModal() {
+        const modal = document.getElementById('media-selector-modal');
+        return modal instanceof HTMLElement ? modal : null;
+      }
+
+      function getMediaFieldElements(fieldId) {
+        if (!fieldId) {
+          return {
+            fieldId: '',
+            hiddenInput: null,
+            preview: null,
+            mediaField: null,
+            actionsDiv: null,
+          };
+        }
+
+        const hiddenInput = document.getElementById(fieldId);
+        const preview = document.getElementById(fieldId + '-preview');
+        const mediaField = hiddenInput?.closest('.media-field-container') || null;
+        const actionsDiv = mediaField?.querySelector('.media-actions') || null;
+
+        return {
+          fieldId,
+          hiddenInput,
+          preview,
+          mediaField,
+          actionsDiv,
+        };
+      }
+
+      function getActiveMediaTarget() {
+        const modal = getActiveMediaModal();
+        const fieldId = modal?.dataset.targetFieldId || '';
+        return {
+          modal,
+          originalValue: modal?.dataset.originalValue || '',
+          ...getMediaFieldElements(fieldId),
+        };
+      }
+
+      function ensureSingleMediaRemoveButton(fieldId, actionsDiv) {
+        if (!(actionsDiv instanceof HTMLElement)) return;
+        const existingRemoveButton = actionsDiv.querySelector('[data-media-remove="true"]');
+        if (existingRemoveButton) return;
+
+        const removeBtn = document.createElement('button');
+        removeBtn.type = 'button';
+        removeBtn.setAttribute('data-media-remove', 'true');
+        removeBtn.onclick = () => clearMediaField(fieldId);
+        removeBtn.className = 'inline-flex items-center px-4 py-2 bg-red-600 text-white rounded-xl hover:bg-red-700 transition-all';
+        removeBtn.textContent = 'Remove';
+        actionsDiv.appendChild(removeBtn);
+      }
 
       function openMediaSelector(fieldId) {
-        currentMediaFieldId = fieldId;
+        const existingModal = getActiveMediaModal();
+        if (existingModal) {
+          existingModal.remove();
+        }
+
         // Store the original value in case user cancels
-        const originalValue = document.getElementById(fieldId)?.value || '';
+        const originalValue = getMediaFieldElements(fieldId).hiddenInput?.value || '';
 
         // Open media library modal
         const modal = document.createElement('div');
         modal.className = 'fixed inset-0 bg-black/50 backdrop-blur-sm flex items-center justify-center z-50';
         modal.id = 'media-selector-modal';
+        modal.dataset.targetFieldId = fieldId;
+        modal.dataset.originalValue = originalValue;
         modal.innerHTML = \`
           <div class="rounded-xl bg-white dark:bg-zinc-900 shadow-xl ring-1 ring-zinc-950/5 dark:ring-white/10 p-6 w-full max-w-4xl max-h-[90vh] overflow-y-auto">
             <h3 class="text-lg font-semibold text-zinc-950 dark:text-white mb-4">Select Media</h3>
             <div id="media-grid-container" hx-get="/admin/media/selector" hx-trigger="load"></div>
             <div class="mt-4 flex justify-end space-x-2">
               <button
-                onclick="cancelMediaSelection('\${fieldId}', '\${originalValue}')"
+                onclick="cancelMediaSelection()"
                 class="rounded-lg bg-white dark:bg-zinc-800 px-4 py-2 text-sm font-semibold text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 hover:bg-zinc-50 dark:hover:bg-zinc-700 transition-colors">
                 Cancel
               </button>
@@ -6741,23 +7609,23 @@ function renderContentFormPage(data) {
       }
 
       function closeMediaSelector() {
-        const modal = document.getElementById('media-selector-modal');
+        const modal = getActiveMediaModal();
         if (modal) {
           modal.remove();
         }
-        currentMediaFieldId = null;
       }
 
-      function cancelMediaSelection(fieldId, originalValue) {
+      function cancelMediaSelection() {
+        const { hiddenInput, preview, originalValue } = getActiveMediaTarget();
+
         // Restore original value
-        const hiddenInput = document.getElementById(fieldId);
         if (hiddenInput) {
           hiddenInput.value = originalValue;
+          notifyFieldChange(hiddenInput);
         }
 
         // If original value was empty, hide the preview and show select button
         if (!originalValue) {
-          const preview = document.getElementById(fieldId + '-preview');
           if (preview) {
             preview.classList.add('hidden');
           }
@@ -6768,11 +7636,11 @@ function renderContentFormPage(data) {
       }
 
       function clearMediaField(fieldId) {
-        const hiddenInput = document.getElementById(fieldId);
-        const preview = document.getElementById(fieldId + '-preview');
+        const { hiddenInput, preview, actionsDiv } = getMediaFieldElements(fieldId);
 
         if (hiddenInput) {
           hiddenInput.value = '';
+          notifyFieldChange(hiddenInput);
         }
 
         if (preview) {
@@ -6782,25 +7650,34 @@ function renderContentFormPage(data) {
           }
           preview.classList.add('hidden');
         }
+
+        const removeButton = actionsDiv?.querySelector('[data-media-remove="true"]');
+        if (removeButton) {
+          removeButton.remove();
+        }
       }
 
       // Global function to remove a single media from multiple selection
       window.removeMediaFromMultiple = function(fieldId, urlToRemove) {
-        const hiddenInput = document.getElementById(fieldId);
+        const { hiddenInput, preview } = getMediaFieldElements(fieldId);
         if (!hiddenInput) return;
 
         const values = hiddenInput.value.split(',').filter(url => url !== urlToRemove);
         hiddenInput.value = values.join(',');
+        notifyFieldChange(hiddenInput);
 
         // Remove preview item
-        const previewItem = document.querySelector(\`[data-url="\${urlToRemove}"]\`);
+        const previewItem =
+          preview &&
+          Array.from(preview.querySelectorAll('[data-url]')).find(
+            (item) => item.getAttribute('data-url') === urlToRemove,
+          );
         if (previewItem) {
           previewItem.remove();
         }
 
         // Hide preview grid if empty
         if (values.length === 0) {
-          const preview = document.getElementById(fieldId + '-preview');
           if (preview) {
             preview.classList.add('hidden');
           }
@@ -6809,39 +7686,24 @@ function renderContentFormPage(data) {
 
       // Global function called by media selector buttons
       window.selectMediaFile = function(mediaId, mediaUrl, filename) {
-        if (!currentMediaFieldId) {
+        const { fieldId, hiddenInput, preview, actionsDiv } = getActiveMediaTarget();
+        if (!fieldId || !hiddenInput) {
           console.error('No field ID set for media selection');
           return;
         }
 
-        const fieldId = currentMediaFieldId;
-
         // Set the hidden input value to the media URL (not ID)
-        const hiddenInput = document.getElementById(fieldId);
-        if (hiddenInput) {
-          hiddenInput.value = mediaUrl;
-        }
+        hiddenInput.value = mediaUrl;
+        notifyFieldChange(hiddenInput);
 
         // Update the preview
-        const preview = document.getElementById(fieldId + '-preview');
         if (preview) {
           preview.innerHTML = \`<img src="\${mediaUrl}" alt="\${filename}" class="w-32 h-32 object-cover rounded-lg border border-white/20">\`;
           preview.classList.remove('hidden');
         }
 
         // Show the remove button by finding the media actions container and updating it
-        const mediaField = hiddenInput?.closest('.media-field-container');
-        if (mediaField) {
-          const actionsDiv = mediaField.querySelector('.media-actions');
-          if (actionsDiv && !actionsDiv.querySelector('button:has-text("Remove")')) {
-            const removeBtn = document.createElement('button');
-            removeBtn.type = 'button';
-            removeBtn.onclick = () => clearMediaField(fieldId);
-            removeBtn.className = 'inline-flex items-center px-4 py-2 bg-red-600 text-white rounded-xl hover:bg-red-700 transition-all';
-            removeBtn.textContent = 'Remove';
-            actionsDiv.appendChild(removeBtn);
-          }
-        }
+        ensureSingleMediaRemoveButton(fieldId, actionsDiv);
 
         // DON'T close the modal - let user click OK button
         // Visual feedback: highlight the selected item
@@ -6855,7 +7717,9 @@ function renderContentFormPage(data) {
       };
 
       function setMediaField(fieldId, mediaUrl) {
-        document.getElementById(fieldId).value = mediaUrl;
+        const hiddenInput = document.getElementById(fieldId);
+        hiddenInput.value = mediaUrl;
+        notifyFieldChange(hiddenInput);
         const preview = document.getElementById(fieldId + '-preview');
         preview.innerHTML = \`<img src="\${mediaUrl}" alt="Selected media" class="w-32 h-32 object-cover rounded-lg ring-1 ring-zinc-950/10 dark:ring-white/10">\`;
         preview.classList.remove('hidden');
@@ -11450,6 +12314,13 @@ function renderUsersListPage(data) {
 // src/routes/admin-users.ts
 var userRoutes = new Hono();
 userRoutes.use("*", requireAuth());
+userRoutes.use("/users/*", requireRole(["admin"]));
+userRoutes.use("/users", requireRole(["admin"]));
+userRoutes.use("/invite-user", requireRole(["admin"]));
+userRoutes.use("/resend-invitation/*", requireRole(["admin"]));
+userRoutes.use("/cancel-invitation/*", requireRole(["admin"]));
+userRoutes.use("/activity-logs", requireRole(["admin"]));
+userRoutes.use("/activity-logs/*", requireRole(["admin"]));
 userRoutes.get("/", (c) => {
   return c.redirect("/admin/dashboard");
 });
@@ -11937,7 +12808,9 @@ userRoutes.post("/users/new", async (c) => {
     const email = formData.get("email")?.toString()?.trim().toLowerCase() || "";
     const phone = sanitizeInput(formData.get("phone")?.toString()) || null;
     const bio = sanitizeInput(formData.get("bio")?.toString()) || null;
-    const role = formData.get("role")?.toString() || "viewer";
+    const roleInput = formData.get("role")?.toString() || "viewer";
+    const validRoles = ["admin", "editor", "author", "viewer"];
+    const role = validRoles.includes(roleInput) ? roleInput : "viewer";
     const password = formData.get("password")?.toString() || "";
     const confirmPassword = formData.get("confirm_password")?.toString() || "";
     const isActive = formData.get("is_active") === "1";
@@ -12157,7 +13030,9 @@ userRoutes.put("/users/:id", async (c) => {
     const username = sanitizeInput(formData.get("username")?.toString());
     const email = formData.get("email")?.toString()?.trim().toLowerCase() || "";
     const phone = sanitizeInput(formData.get("phone")?.toString()) || null;
-    const role = formData.get("role")?.toString() || "viewer";
+    const roleInput = formData.get("role")?.toString() || "viewer";
+    const validRoles = ["admin", "editor", "author", "viewer"];
+    const role = validRoles.includes(roleInput) ? roleInput : "viewer";
     const isActive = formData.get("is_active") === "1";
     const emailVerified = formData.get("email_verified") === "1";
     const profileDisplayName = sanitizeInput(formData.get("profile_display_name")?.toString()) || null;
@@ -17482,6 +18357,18 @@ adminPluginRoutes.post("/:id/settings", async (c) => {
     const settings = await c.req.json();
     const pluginService = new PluginService(db);
     await pluginService.updatePluginSettings(pluginId, settings);
+    if (pluginId === "core-auth") {
+      try {
+        const cacheKv = c.env.CACHE_KV;
+        if (cacheKv) {
+          await cacheKv.delete("auth:settings");
+          await cacheKv.delete("auth:registration-enabled");
+          console.log("[AuthSettings] Cache cleared after updating authentication settings");
+        }
+      } catch (cacheError) {
+        console.error("[AuthSettings] Failed to clear cache:", cacheError);
+      }
+    }
     return c.json({ success: true });
   } catch (error) {
     console.error("Error updating plugin settings:", error);
@@ -22426,6 +23313,9 @@ function renderCollectionFormPage(data) {
 // src/routes/admin-collections.ts
 var adminCollectionsRoutes = new Hono();
 adminCollectionsRoutes.use("*", requireAuth());
+adminCollectionsRoutes.post("*", requireRole(["admin"]));
+adminCollectionsRoutes.put("*", requireRole(["admin"]));
+adminCollectionsRoutes.delete("*", requireRole(["admin"]));
 adminCollectionsRoutes.get("/", async (c) => {
   try {
     const user = c.get("user");
@@ -27936,5 +28826,5 @@ var ROUTES_INFO = {
 };
 
 export { ROUTES_INFO, adminCheckboxRoutes, adminCollectionsRoutes, adminDesignRoutes, adminFormsRoutes, adminLogsRoutes, adminMediaRoutes, adminPluginRoutes, adminSettingsRoutes, admin_api_default, admin_code_examples_default, admin_content_default, admin_testimonials_default, api_content_crud_default, api_default, api_media_default, api_system_default, auth_default, getConfirmationDialogScript2 as getConfirmationDialogScript, public_forms_default, renderConfirmationDialog2 as renderConfirmationDialog, router, router2, test_cleanup_default, userRoutes };
-//# sourceMappingURL=chunk-2JGQKF7B.js.map
-//# sourceMappingURL=chunk-2JGQKF7B.js.map
+//# sourceMappingURL=chunk-JTNUM7JE.js.map
+//# sourceMappingURL=chunk-JTNUM7JE.js.map