@xleddyl/nuxt-cms 0.9.4 → 0.10.0

package/dist/module.mjs

@@ -3,18 +3,23 @@ import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { extname, resolve, isAbsolute, join, relative, dirname } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { defineNuxtModule, createResolver, useLogger, addImports, addTemplate, addServerPlugin, addTypeTemplate, addComponentsDir, tryResolveModule, addRouteMiddleware, extendPages, addServerHandler, resolvePath, addComponent } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, useLogger, addImports, addTemplate, addPlugin, addServerPlugin, addTypeTemplate, addComponentsDir, tryResolveModule, addRouteMiddleware, extendPages, addServerHandler, resolvePath, addComponent, hasNuxtModule } from '@nuxt/kit';
 import { introspectionFromSchema, buildSchema } from 'graphql';
 import { minifyIntrospection, outputIntrospectionFile } from 'gql.tada/internal';
 import { createJiti } from 'jiti';
-import { typeName, blockTypeName as blockTypeName$1, blocksFieldTypeName, renderGraphqlSdl } from '../dist/runtime/shared/graphql-sdl.js';
-import { migrationsDirFor } from '../dist/runtime/shared/migrations-dir.js';
-import { entryFieldsFor, isPrivateField, blockTypeName, pageColumnFields, isTranslatableField, isTranslatableMediaField, isStringListField, pageAllFields, normalizeContentEntries, PAGE_PATH_FIELD, pageRoutes, isCollectionKind, isMultiSelect, layoutErrors, listErrors, mobileMediaKey, fieldConditions, selectOptionValues, pageFieldsTableName, pageMediaTableName, CONTENT_SYSTEM_FIELDS, isRequiredField, pageFields, mediaTypeFilter, DEFAULT_MEDIA_MAX_FILE_SIZE, normalizeCmsConfig } from '../dist/runtime/shared/index.js';
+import { typeName, blocksFieldTypeName, blockTypeName as blockTypeName$1, renderGraphqlSdl } from '../dist/runtime/shared/graphql-sdl.js';
+import { migrationsDirFor, MIGRATION_FIXES_FILE, migrationSqlFiles, fixNewMigrations } from '../dist/runtime/shared/migrations-dir.js';
+import { blocksFieldPaths, entryFieldsFor, isPrivateField, blockTypeName, pageColumnFields, isTranslatableField, isTranslatableMediaField, isStringListField, pageAllFields, isRequiredField, normalizeContentEntries, contentRouteConfigErrors, PAGE_PATH_FIELD, pageRoutes, isCollectionKind, isMultiSelect, layoutErrors, listErrors, mobileMediaKey, relationTarget, pageFieldsTableName, pageMediaTableName, contentRouteClashErrors, CONTENT_SYSTEM_FIELDS, CONTENT_ROUTE_FIELDS, declaredLinkTargets, isLinkTargetEntry, MAX_BLOCKS_DEPTH, CONDITION_GROUPS, normalizeTags, selectOptionValues, CONDITION_OPERATORS, routedContentNames, pageFields, isRoutedContent, mediaTypeFilter, DEFAULT_MEDIA_MAX_FILE_SIZE, normalizeCmsConfig } from '../dist/runtime/shared/index.js';
 import { previewPathErrors, DEFAULT_CMS_PREVIEW_PATH } from '../dist/runtime/shared/preview.js';
+import { previewBannerErrors } from '../dist/runtime/shared/preview-links.js';
+import { seoOptionErrors, normalizeSiteUrl, SITEMAP_PATH, resolveSeoSwitches, ROBOTS_PATH, missingSiteUrlWarning, SITEMAP_CONFLICT_MODULES, ROBOTS_CONFLICT_MODULES } from '../dist/runtime/shared/seo.js';
 import { scanMediaDirectory, readMediaFileMeta } from '../dist/runtime/server/utils/media-sync.js';
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
+import { isUniqueValueField, UNIQUE_FIELD_TYPES, IMMUTABLE_FIELD_TYPES, DEFAULT_FIELD_TYPES, DEFAULT_NOW, DEFAULT_TODAY } from '../dist/runtime/shared/field-options.js';
 import { routePathsFromDir, resolvePageRoutes } from '../dist/runtime/shared/page-routes.js';
+import { CMS_ENTRY_ACTIONS, CMS_MEDIA_ACTIONS } from '../dist/runtime/shared/hooks.js';
+import { validateRoles } from '../dist/runtime/shared/roles.js';
 
 const DEFAULT_BRAND_TITLE = "nuxt-cms";
 const DEFAULT_BRAND_SUBTITLE = "Content studio";
@@ -101,22 +106,42 @@ function renderBrandFile(brand) {
   ].join("\n");
 }
 
+function resolveCmsImageSetup(installed, options) {
+  const provider = options.image?.provider;
+  return {
+    nuxtImage: installed,
+    provider: installed && typeof provider === "string" && provider ? provider : null
+  };
+}
+function renderImageFile(setup) {
+  const lines = [`import type { Component } from 'vue'`];
+  if (setup.nuxtImage) lines.push(`import { NuxtImg, NuxtPicture } from '#components'`);
+  lines.push(
+    ``,
+    `export const cmsNuxtImg: Component | null = ${setup.nuxtImage ? "NuxtImg" : "null"}`,
+    `export const cmsNuxtPicture: Component | null = ${setup.nuxtImage ? "NuxtPicture" : "null"}`,
+    `export const cmsImageProvider: string | null = ${JSON.stringify(setup.provider)}`,
+    ``
+  );
+  return lines.join("\n");
+}
+
 function componentPascalName(name) {
   return name.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function collectBlockComponents(config) {
   const refs = [];
   for (const [entryName, entry] of Object.entries(config)) {
-    for (const [fieldKey, field] of Object.entries(entryFieldsFor(entry))) {
-      if (field.type !== "blocks" || isPrivateField(field)) continue;
+    for (const { field, schemaPath } of blocksFieldPaths(entryFieldsFor(entry))) {
+      if (isPrivateField(field)) continue;
       for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
         if (typeof block.component !== "string" || !block.component.trim()) continue;
         refs.push({
           entry: entryName,
-          field: fieldKey,
+          field: schemaPath.join("."),
           block: blockName,
           component: componentPascalName(block.component.trim()),
-          typeName: blockTypeName(entryName, fieldKey, blockName)
+          typeName: blockTypeName(entryName, schemaPath, blockName)
         });
       }
     }
@@ -238,13 +263,16 @@ const RESERVED_ENTRY_KEYS = [
   "graphql",
   "settings",
   "cms_media",
+  "cms_preview_links",
+  "cms_redirects",
   "cms_settings",
   "cms_users"
 ];
 const RESERVED_COLUMNS = ["id", "status", "created_at", "updated_at"];
 const TITLE_FIELD_TYPES = ["text", "slug", "email", "number", "date", "datetime", "select"];
 const TRANSLATABLE_FIELD_TYPES = ["text", "richtext", "media"];
-const CONDITION_FIELD_TYPES = [
+const TRANSLATABLE_ERROR = "translatable is only supported on text, richtext, media and link fields";
+const CONDITION_VALUE_TYPES = [
   "select",
   "boolean",
   "text",
@@ -254,12 +282,19 @@ const CONDITION_FIELD_TYPES = [
   "email",
   "slug"
 ];
+const CONDITION_ORDER_TYPES = ["number", "date", "datetime"];
+const CONDITION_LIST_TYPES = ["tags", "select (multiple)", "relation (many-to-many)"];
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
 const COMPONENT_RESERVED_KEYS = ["key", "ref", "class", "style"];
 const RESERVED_TYPE_NAMES = [
   "Query",
   "Mutation",
   "Subscription",
   "CmsMedia",
+  "CmsLink",
+  "CmsLocalePath",
+  "CmsSite",
   "JSON",
   "SortDirection",
   "IntFilter",
@@ -309,6 +344,11 @@ function validateConfig(config, i18n) {
       errors.push(`${at}: kind must be 'collection', 'single', 'page' or 'content'`);
     if (entry.kind === "content") errors.push(...contentErrors(at, entry));
     else if (entry.preview !== void 0) errors.push(`${at}: preview needs kind 'content'`);
+    if (entry.route !== void 0) {
+      if (entry.kind === "content")
+        errors.push(...contentRouteConfigErrors(at, entry.route, { locales }));
+      else errors.push(`${at}: route needs kind 'content'`);
+    }
     if (entry.kind === "page") {
       if (pageEntry) {
         errors.push(
@@ -420,13 +460,12 @@ function validateConfig(config, i18n) {
         columnNames.add(column);
       }
       if (field.translatable) {
-        if (!TRANSLATABLE_FIELD_TYPES.includes(field.type))
-          errors.push(
-            `${fat}: translatable is only supported on text, richtext and media fields`
-          );
+        if (field.type !== "link" && !TRANSLATABLE_FIELD_TYPES.includes(field.type))
+          errors.push(`${fat}: ${TRANSLATABLE_ERROR}`);
         if (!locales.length)
           errors.push(`${fat}: translatable requires cms.i18n.locales in nuxt.config`);
       }
+      errors.push(...linkFieldErrors(fat, field, config));
       if (field.mobile) {
         const mobileKey = mobileMediaKey(key);
         if (field.type !== "media")
@@ -435,48 +474,10 @@ function validateConfig(config, i18n) {
           errors.push(`${fat}: mobile needs the key '${mobileKey}', which is already declared`);
       }
       if (field.type === "select") errors.push(...selectOptionErrors(fat, field));
-      if (field.showIf) {
+      if (field.showIf !== void 0) {
         if (entry.titleField === key)
           errors.push(`${fat}: the titleField cannot be conditional`);
-        for (const condition of fieldConditions(field)) {
-          const cat = `${fat}, showIf on '${condition.field}'`;
-          const target = allFields[condition.field];
-          if (!condition.field || !target) {
-            errors.push(`${cat}: '${condition.field}' is not a declared field`);
-            continue;
-          }
-          if (condition.field === key) {
-            errors.push(`${cat}: a field cannot depend on itself`);
-            continue;
-          }
-          if (!CONDITION_FIELD_TYPES.includes(target.type) || isMultiSelect(target)) {
-            errors.push(
-              `${cat}: showIf can only depend on ${CONDITION_FIELD_TYPES.join(
-                ", "
-              )} fields (got '${target.type}')`
-            );
-            continue;
-          }
-          if (isTranslatableField(target)) {
-            errors.push(`${cat}: showIf cannot depend on a translatable field`);
-            continue;
-          }
-          const values = condition.in ?? (condition.eq === void 0 ? null : [condition.eq]);
-          if (!values || !values.length) {
-            errors.push(`${cat}: showIf requires 'eq' or a non-empty 'in'`);
-            continue;
-          }
-          if (condition.in && condition.eq !== void 0)
-            errors.push(`${cat}: showIf accepts either 'eq' or 'in', not both`);
-          if (target.type === "select") {
-            const options = selectOptionValues(target);
-            const unknown = values.filter((value) => !options.includes(String(value)));
-            if (unknown.length)
-              errors.push(
-                `${cat}: ${unknown.map((value) => `'${String(value)}'`).join(", ")} not in the options of '${condition.field}'`
-              );
-          }
-        }
+        errors.push(...showIfErrors(fat, key, field.showIf, allFields, "a declared field"));
       }
       if (field.type === "slug" && field.from) {
         const source = entry.fields?.[field.from];
@@ -489,59 +490,16 @@ function validateConfig(config, i18n) {
       } else if (field.suggestions !== void 0) {
         errors.push(`${fat}: suggestions is only supported on tags fields`);
       }
-      if (field.type !== "blocks" && field.type !== "tags" && (field.min !== void 0 || field.max !== void 0))
-        errors.push(`${fat}: min and max are only supported on blocks and tags fields`);
+      errors.push(...valueBoundsErrors(fat, field));
+      errors.push(...fieldOptionErrors(fat, field, entry, null));
       if (field.type === "blocks") {
         if (field.translatable) errors.push(`${fat}: blocks fields cannot be translatable`);
-        errors.push(...blocksCountErrors(fat, field));
-        if (!field.blocks || !Object.keys(field.blocks).length) {
-          errors.push(`${fat}: blocks requires a non-empty blocks map`);
-        }
-        for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
-          const bat = `${fat}, block '${blockName}'`;
-          if (!IDENTIFIER.test(blockName))
-            errors.push(`${bat}: key must be a valid identifier`);
-          if (!block.fields || !Object.keys(block.fields).length)
-            errors.push(`${bat}: fields must not be empty`);
-          errors.push(...blockMetaErrors(bat, block));
-          for (const [blockFieldKey, blockField] of Object.entries(block.fields ?? {})) {
-            const bfat = `${bat}, field '${blockFieldKey}'`;
-            if (!IDENTIFIER.test(blockFieldKey))
-              errors.push(`${bfat}: key must be a valid identifier`);
-            if (blockFieldKey === "type")
-              errors.push(`${bfat}: 'type' is reserved inside blocks`);
-            if (["relation", "blocks", "slug", "tags"].includes(blockField.type)) {
-              errors.push(
-                `${bfat}: ${blockField.type} fields are not supported inside blocks`
-              );
-            }
-            if (blockField.translatable) {
-              if (!TRANSLATABLE_FIELD_TYPES.includes(blockField.type))
-                errors.push(
-                  `${bfat}: translatable is only supported on text, richtext and media fields`
-                );
-              if (!locales.length)
-                errors.push(
-                  `${bfat}: translatable requires cms.i18n.locales in nuxt.config`
-                );
-            }
-            if (blockField.private)
-              errors.push(`${bfat}: private fields are not supported inside blocks`);
-            if (blockField.showIf)
-              errors.push(`${bfat}: showIf is not supported inside blocks`);
-            if (blockField.mobile)
-              errors.push(`${bfat}: mobile is not supported inside blocks`);
-            if (blockField.type === "select")
-              errors.push(...selectOptionErrors(bfat, blockField));
-            if (blockField.type === "select" && blockField.multiple) {
-              errors.push(`${bfat}: multiple select is not supported inside blocks`);
-            }
-          }
-        }
+        errors.push(...blocksFieldErrors(fat, field, 1, { config, entry, locales }));
       }
       if (field.type === "relation") {
-        const target = field.to ? config[field.to] : void 0;
-        if (!field.to || !target) {
+        const to = relationTarget(field);
+        const target = to ? config[to] : void 0;
+        if (!to || !target) {
           errors.push(`${fat}: relation target '${field.to}' is not in the registry`);
         } else {
           if (!isCollectionKind(target))
@@ -571,6 +529,8 @@ function validateConfig(config, i18n) {
   }
   const sqlTableNames = /* @__PURE__ */ new Map([
     ["cms_media", "the built-in media table"],
+    ["cms_preview_links", "the built-in preview links table"],
+    ["cms_redirects", "the built-in redirects table"],
     ["cms_settings", "the built-in settings table"],
     ["cms_users", "the built-in users table"]
   ]);
@@ -596,6 +556,95 @@ function validateConfig(config, i18n) {
         registerTable(`${name}_${snakeCase(key)}`, `the join table of '${name}.${key}'`);
     }
   }
+  errors.push(...contentRouteClashErrors(config));
+  errors.push(...blockTypeNameErrors(config));
+  return errors;
+}
+function blocksFieldErrors(fat, field, depth, scope) {
+  const { config, entry, locales } = scope;
+  const errors = [];
+  errors.push(...blocksCountErrors(fat, field));
+  if (!field.blocks || !Object.keys(field.blocks).length) {
+    errors.push(`${fat}: blocks requires a non-empty blocks map`);
+  }
+  for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+    const bat = `${fat}, block '${blockName}'`;
+    if (!IDENTIFIER.test(blockName)) errors.push(`${bat}: key must be a valid identifier`);
+    if (!block.fields || !Object.keys(block.fields).length)
+      errors.push(`${bat}: fields must not be empty`);
+    errors.push(...blockMetaErrors(bat, block));
+    errors.push(...layoutErrors(bat, block.fields ?? {}, block.layout));
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields ?? {})) {
+      const bfat = `${bat}, field '${blockFieldKey}'`;
+      if (!IDENTIFIER.test(blockFieldKey)) errors.push(`${bfat}: key must be a valid identifier`);
+      if (blockFieldKey === "type") errors.push(`${bfat}: 'type' is reserved inside blocks`);
+      if (["relation", "slug", "tags"].includes(blockField.type)) {
+        errors.push(`${bfat}: ${blockField.type} fields are not supported inside blocks`);
+      }
+      errors.push(...linkFieldErrors(bfat, blockField, config));
+      if (blockField.translatable) {
+        if (blockField.type === "blocks")
+          errors.push(`${bfat}: blocks fields cannot be translatable`);
+        else if (blockField.type !== "link" && !TRANSLATABLE_FIELD_TYPES.includes(blockField.type))
+          errors.push(`${bfat}: ${TRANSLATABLE_ERROR}`);
+        if (!locales.length)
+          errors.push(`${bfat}: translatable requires cms.i18n.locales in nuxt.config`);
+      }
+      if (blockField.private)
+        errors.push(`${bfat}: private fields are not supported inside blocks`);
+      if (blockField.showIf !== void 0)
+        errors.push(
+          ...showIfErrors(
+            bfat,
+            blockFieldKey,
+            blockField.showIf,
+            block.fields ?? {},
+            "a field of this block"
+          )
+        );
+      if (blockField.mobile)
+        errors.push(`${bfat}: mobile is not supported inside blocks`);
+      if (blockField.type === "blocks") {
+        if (depth >= MAX_BLOCKS_DEPTH)
+          errors.push(
+            `${bfat}: blocks nest at most ${MAX_BLOCKS_DEPTH} levels deep (a blocks field in a block in a blocks field counts as 2)`
+          );
+        else errors.push(...blocksFieldErrors(bfat, blockField, depth + 1, scope));
+        errors.push(...fieldOptionErrors(bfat, blockField, entry, "blocks"));
+        continue;
+      }
+      errors.push(...valueBoundsErrors(bfat, blockField));
+      errors.push(...fieldOptionErrors(bfat, blockField, entry, "blocks"));
+      if (blockField.type === "select") errors.push(...selectOptionErrors(bfat, blockField));
+      if (blockField.type === "select" && blockField.multiple) {
+        errors.push(`${bfat}: multiple select is not supported inside blocks`);
+      }
+    }
+  }
+  return errors;
+}
+function blockTypeNameErrors(config) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(config)) seen.set(typeName(name), `entry '${name}'`);
+  const claim = (type, owner) => {
+    const existing = seen.get(type);
+    if (existing && existing !== owner)
+      errors.push(
+        `cms.config: GraphQL type name '${type}' of ${owner} clashes with ${existing}, rename a block or field`
+      );
+    else seen.set(type, owner);
+  };
+  for (const [name, entry] of Object.entries(config)) {
+    const fields = entry.kind === "page" ? pageAllFields(entry) : entry.fields ?? {};
+    for (const { field, schemaPath } of blocksFieldPaths(fields)) {
+      if (field.private) continue;
+      const where = `'${name}.${schemaPath.join(".")}'`;
+      claim(blocksFieldTypeName(name, schemaPath), `the blocks of ${where}`);
+      for (const blockName of Object.keys(field.blocks ?? {}))
+        claim(blockTypeName$1(name, schemaPath, blockName), `block '${blockName}' of ${where}`);
+    }
+  }
   return errors;
 }
 function contentErrors(at, entry) {
@@ -604,6 +653,8 @@ function contentErrors(at, entry) {
   for (const key of entry.declared?.fields ?? []) {
     if (system.includes(key))
       errors.push(`${at}: '${key}' is a system field of content entries, remove it from fields`);
+    else if (entry.route !== void 0 && CONTENT_ROUTE_FIELDS.includes(key))
+      errors.push(`${at}: '${key}' is reserved on content entries with a route`);
   }
   if (entry.declared?.titleField !== void 0)
     errors.push(`${at}: content entries use 'title' as titleField, remove titleField`);
@@ -625,6 +676,43 @@ function contentErrors(at, entry) {
   }
   return errors;
 }
+function linkFieldErrors(at, field, config) {
+  const errors = [];
+  if (field.type !== "link") {
+    if (field.external !== void 0)
+      errors.push(`${at}: external is only supported on link fields`);
+    if (field.withLabel !== void 0)
+      errors.push(`${at}: withLabel is only supported on link fields`);
+    return errors;
+  }
+  if (field.external !== void 0 && typeof field.external !== "boolean")
+    errors.push(`${at}: external must be a boolean`);
+  if (field.withLabel !== void 0 && typeof field.withLabel !== "boolean")
+    errors.push(`${at}: withLabel must be a boolean`);
+  if (field.translatable && !field.withLabel)
+    errors.push(`${at}: translatable needs withLabel (only the link text is translated)`);
+  const to = field.to;
+  const declared = declaredLinkTargets(field);
+  if (to !== void 0 && (!declared || declared.length !== to.length)) {
+    errors.push(`${at}: to must be a list of entry names`);
+    return errors;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of declared ?? []) {
+    if (seen.has(name)) errors.push(`${at}: link target '${name}' is listed twice`);
+    seen.add(name);
+    const target = config[name];
+    if (!target) errors.push(`${at}: link target '${name}' is not in the registry`);
+    else if (!isLinkTargetEntry(target))
+      errors.push(
+        `${at}: link target '${name}' must be the page entry or a content entry with a route`
+      );
+  }
+  const targets = declared ?? Object.keys(config).filter((name) => isLinkTargetEntry(config[name]));
+  if (field.external === false && !targets.length)
+    errors.push(`${at}: the link allows no target: list entries in 'to' or allow external URLs`);
+  return errors;
+}
 function selectOptionErrors(at, field) {
   const errors = [];
   if (!Array.isArray(field.options) || !field.options.length)
@@ -664,6 +752,282 @@ function blocksCountErrors(at, field) {
     errors.push(`${at}: min (${field.min}) cannot be greater than max (${field.max})`);
   return errors;
 }
+function conditionTypeName(field) {
+  if (isMultiSelect(field)) return "select (multiple)";
+  if (field.type === "relation") return `relation (${field.cardinality ?? "many-to-one"})`;
+  return field.type;
+}
+function isConditionListTarget(field) {
+  return isStringListField(field) || isManyToMany(field);
+}
+function isDateValue(value) {
+  return typeof value === "string" && DATE_PATTERN.test(value) && !Number.isNaN((/* @__PURE__ */ new Date(`${value}T00:00:00Z`)).getTime());
+}
+function isDateTimeValue(value) {
+  return typeof value === "string" && DATETIME_PATTERN.test(value) && !Number.isNaN(new Date(value).getTime());
+}
+function conditionValueExpectation(field) {
+  switch (field.type) {
+    case "boolean":
+      return { label: "a boolean", test: (value) => typeof value === "boolean" };
+    case "number":
+      return {
+        label: "a number",
+        test: (value) => typeof value === "number" && Number.isFinite(value)
+      };
+    case "date":
+      return { label: "a yyyy-mm-dd date", test: isDateValue };
+    case "datetime":
+      return {
+        label: "an ISO 8601 date and time with a time zone",
+        test: isDateTimeValue
+      };
+    default:
+      return { label: "a string", test: (value) => typeof value === "string" };
+  }
+}
+function conditionOptionErrors(at, name, target, values) {
+  const options = selectOptionValues(target);
+  const unknown = values.filter((value) => !options.includes(String(value)));
+  if (!unknown.length) return [];
+  return [
+    `${at}: ${unknown.map((value) => `'${String(value)}'`).join(", ")} not in the options of '${name}'`
+  ];
+}
+const ORDER_OPERATORS = ["gt", "gte", "lt", "lte"];
+function conditionLeafErrors(at, key, condition, scope, scopeLabel) {
+  const name = condition.field;
+  const cat = `${at}, showIf on '${String(name)}'`;
+  if (typeof name !== "string" || !name || !Object.hasOwn(scope, name))
+    return [`${cat}: '${String(name)}' is not ${scopeLabel}`];
+  if (name === key) return [`${cat}: a field cannot depend on itself`];
+  const errors = [];
+  const target = scope[name];
+  const operators = CONDITION_OPERATORS;
+  const unknown = Object.keys(condition).filter((k) => k !== "field" && !operators.includes(k));
+  if (unknown.length)
+    errors.push(`${cat}: unknown showIf key ${unknown.map((k) => `'${k}'`).join(", ")}`);
+  const used = CONDITION_OPERATORS.filter((operator) => condition[operator] !== void 0);
+  if (!used.length) {
+    errors.push(`${cat}: showIf needs an operator (${CONDITION_OPERATORS.join(", ")})`);
+    return errors;
+  }
+  const type = conditionTypeName(target);
+  for (const operator of used) {
+    const value = condition[operator];
+    if (operator === "empty") {
+      if (target.type === "boolean")
+        errors.push(`${cat}: 'empty' does not apply to boolean fields, use 'eq'`);
+      else if (typeof value !== "boolean") errors.push(`${cat}: 'empty' must be true or false`);
+      continue;
+    }
+    if (isTranslatableField(target)) {
+      errors.push(
+        `${cat}: showIf cannot depend on a translatable field with '${operator}', only with 'empty'`
+      );
+      continue;
+    }
+    if (operator === "has") {
+      if (!isConditionListTarget(target))
+        errors.push(
+          `${cat}: showIf can only depend on ${CONDITION_LIST_TYPES.join(
+            ", "
+          )} fields with 'has' (got '${type}')`
+        );
+      else if (typeof value !== "string" || !value)
+        errors.push(`${cat}: 'has' needs a non-empty string`);
+      else if (target.type === "select")
+        errors.push(...conditionOptionErrors(cat, name, target, [value]));
+      continue;
+    }
+    const allowed = ORDER_OPERATORS.includes(operator) ? CONDITION_ORDER_TYPES : CONDITION_VALUE_TYPES;
+    if (!allowed.includes(target.type) || isMultiSelect(target)) {
+      errors.push(
+        `${cat}: showIf can only depend on ${allowed.join(
+          ", "
+        )} fields with '${operator}' (got '${type}')`
+      );
+      continue;
+    }
+    const isList = operator === "in" || operator === "notIn";
+    if (isList && (!Array.isArray(value) || !value.length)) {
+      errors.push(`${cat}: '${operator}' needs a non-empty list`);
+      continue;
+    }
+    const values = isList ? value : [value];
+    const expectation = conditionValueExpectation(target);
+    const wrong = values.filter((item) => !expectation.test(item));
+    if (wrong.length)
+      errors.push(
+        `${cat}: '${operator}' needs ${expectation.label} for a ${type} field (got ${wrong.map((item) => JSON.stringify(item)).join(", ")})`
+      );
+    else if (target.type === "select")
+      errors.push(...conditionOptionErrors(cat, name, target, values));
+  }
+  return errors;
+}
+function showIfErrors(at, key, showIf, scope, scopeLabel) {
+  const errors = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      if (!node.length) errors.push(`${at}: showIf needs at least one condition`);
+      for (const child of node) visit(child);
+      return;
+    }
+    if (!node || typeof node !== "object") {
+      errors.push(`${at}: every showIf condition must be an object`);
+      return;
+    }
+    const record = node;
+    const group = CONDITION_GROUPS.find((name) => Object.hasOwn(record, name));
+    if (!group) {
+      errors.push(...conditionLeafErrors(at, key, record, scope, scopeLabel));
+      return;
+    }
+    if (Object.keys(record).length !== 1) {
+      errors.push(`${at}: a showIf group holds only one of 'all', 'any' or 'not'`);
+      return;
+    }
+    const inner = record[group];
+    if (group === "not") {
+      if (!inner || typeof inner !== "object" || Array.isArray(inner))
+        errors.push(`${at}: showIf 'not' takes one condition`);
+      else visit(inner);
+      return;
+    }
+    if (!Array.isArray(inner) || !inner.length) {
+      errors.push(`${at}: showIf '${group}' takes a non-empty list of conditions`);
+      return;
+    }
+    for (const child of inner) visit(child);
+  };
+  visit(showIf);
+  return errors;
+}
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function valueBoundsErrors(at, field) {
+  if (field.type === "blocks" || field.type === "tags") return [];
+  const errors = [];
+  const raw = field;
+  for (const name of ["minLength", "maxLength"])
+    if (raw[name] !== void 0)
+      errors.push(
+        `${at}: ${name} is not an option, use ${name.slice(0, 3)} (characters on text fields)`
+      );
+  if (field.min === void 0 && field.max === void 0) return errors;
+  if (field.type === "number") {
+    const isBound = (value) => typeof value === "number" && Number.isFinite(value);
+    if (field.min !== void 0 && !isBound(field.min)) errors.push(`${at}: min must be a number`);
+    if (field.max !== void 0 && !isBound(field.max)) errors.push(`${at}: max must be a number`);
+    if (isBound(field.min) && isBound(field.max) && field.min > field.max)
+      errors.push(`${at}: min (${field.min}) cannot be greater than max (${field.max})`);
+    return errors;
+  }
+  if (field.type === "text") {
+    const isLength = (value, least) => typeof value === "number" && Number.isInteger(value) && value >= least;
+    if (field.min !== void 0 && !isLength(field.min, 0))
+      errors.push(`${at}: min must be an integer of 0 or more (characters)`);
+    if (field.max !== void 0 && !isLength(field.max, 1))
+      errors.push(`${at}: max must be an integer of 1 or more (characters)`);
+    if (isLength(field.min, 0) && isLength(field.max, 1) && field.min > field.max)
+      errors.push(`${at}: min (${field.min}) cannot be greater than max (${field.max})`);
+    return errors;
+  }
+  errors.push(`${at}: min and max are only supported on number, text, blocks and tags fields`);
+  return errors;
+}
+function defaultValueError(field) {
+  const value = field.default;
+  switch (field.type) {
+    case "text":
+    case "richtext": {
+      if (typeof value !== "string") return "default must be a string";
+      if (field.type === "text" && value.trim()) {
+        if (field.min !== void 0 && value.length < field.min)
+          return `default is shorter than min (${field.min})`;
+        if (field.max !== void 0 && value.length > field.max)
+          return `default is longer than max (${field.max})`;
+      }
+      return null;
+    }
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) return "default must be a number";
+      if (field.integer && !Number.isInteger(value)) return "default must be an integer";
+      if (field.min !== void 0 && value < field.min)
+        return `default is lower than min (${field.min})`;
+      if (field.max !== void 0 && value > field.max)
+        return `default is greater than max (${field.max})`;
+      return null;
+    case "boolean":
+      return typeof value === "boolean" ? null : "default must be true or false";
+    case "date":
+      return value === DEFAULT_TODAY || isDateValue(value) ? null : `default must be '${DEFAULT_TODAY}' or a yyyy-mm-dd date`;
+    case "datetime":
+      return value === DEFAULT_NOW || isDateTimeValue(value) ? null : `default must be '${DEFAULT_NOW}' or an ISO 8601 date and time with a time zone`;
+    case "email":
+      return typeof value === "string" && EMAIL_PATTERN.test(value) ? null : "default must be a valid email";
+    case "select": {
+      const options = selectOptionValues(field);
+      if (!field.multiple)
+        return typeof value === "string" && options.includes(value) ? null : `default must be one of the options (${options.join(", ")})`;
+      if (!Array.isArray(value)) return "default of a multiple select must be a list of options";
+      const unknown = value.filter((item) => typeof item !== "string" || !options.includes(item));
+      if (unknown.length)
+        return `default holds values that are not options: ${unknown.map((item) => JSON.stringify(item)).join(", ")}`;
+      return new Set(value).size === value.length ? null : "default repeats an option";
+    }
+    case "tags": {
+      if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim()))
+        return "default must be a list of non-empty strings";
+      const count = normalizeTags(value).length;
+      return field.max !== void 0 && count > field.max ? `default holds more than max (${field.max}) tags` : null;
+    }
+    default:
+      return `default is only supported on ${DEFAULT_FIELD_TYPES.join(", ")} fields`;
+  }
+}
+function fieldOptionErrors(at, field, entry, scope) {
+  const errors = [];
+  const place = scope === "blocks" ? "inside blocks" : entry.kind === "page" ? "on pages" : null;
+  if (field.default !== void 0) {
+    if (place) errors.push(`${at}: default is not supported ${place}`);
+    else {
+      const problem = defaultValueError(field);
+      if (problem) errors.push(`${at}: ${problem}`);
+    }
+  }
+  if (field.unique !== void 0 && typeof field.unique !== "boolean")
+    errors.push(`${at}: unique must be a boolean`);
+  if (field.unique === true) {
+    if (!UNIQUE_FIELD_TYPES.includes(field.type))
+      errors.push(
+        `${at}: unique is only supported on ${UNIQUE_FIELD_TYPES.join(", ")} fields${field.type === "slug" ? " (a slug is always unique)" : ""}`
+      );
+    else if (place) errors.push(`${at}: unique is not supported ${place}`);
+    else if (entry.kind === "single")
+      errors.push(`${at}: unique is not supported on singles, which hold one item`);
+    else if (field.translatable)
+      errors.push(`${at}: unique is not supported on translatable fields`);
+    else if (field.default !== void 0)
+      errors.push(
+        `${at}: default is not supported on unique fields (every new item would get the same value)`
+      );
+  }
+  if (field.immutable !== void 0 && typeof field.immutable !== "boolean")
+    errors.push(`${at}: immutable must be a boolean`);
+  if (field.immutable === true) {
+    if (!IMMUTABLE_FIELD_TYPES.includes(field.type) || isManyToMany(field))
+      errors.push(
+        `${at}: immutable is only supported on ${IMMUTABLE_FIELD_TYPES.join(
+          ", "
+        )} fields (not many-to-many)`
+      );
+    else if (place) errors.push(`${at}: immutable is not supported ${place}`);
+    else if (field.translatable)
+      errors.push(`${at}: immutable is not supported on translatable fields`);
+  }
+  return errors;
+}
 function tagsOptionErrors(at, field) {
   const errors = [];
   if (field.min !== void 0) errors.push(`${at}: min is not supported on tags fields`);
@@ -691,6 +1055,10 @@ function blockMetaErrors(at, block) {
     errors.push(`${at}: icon must be a non-empty string`);
   if (block.description !== void 0 && typeof block.description !== "string")
     errors.push(`${at}: description must be a string`);
+  if (block.group !== void 0 && (typeof block.group !== "string" || !block.group.trim()))
+    errors.push(`${at}: group must be a non-empty string`);
+  if (block.tags !== void 0 && !(Array.isArray(block.tags) && block.tags.every((tag) => typeof tag === "string" && !!tag.trim())))
+    errors.push(`${at}: tags must be an array of non-empty strings`);
   return errors;
 }
 function pageColumnsErrors(at, entry) {
@@ -722,6 +1090,13 @@ function pageColumnsErrors(at, entry) {
   }
   return errors;
 }
+function uniqueTextColumns(config) {
+  return Object.entries(config).filter(([, entry]) => !entry.table && entry.kind !== "page").flatMap(
+    ([name, entry]) => Object.entries(entry.fields).filter(
+      ([, field]) => isUniqueValueField(field) && field.type !== "number" && !isRequiredField(field)
+    ).map(([key]) => ({ table: name, column: snakeCase(key) }))
+  );
+}
 function snakeCase(key) {
   return key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 }
@@ -748,6 +1123,7 @@ function columnExpr(key, field, dialect, table) {
       break;
     case "json":
     case "blocks":
+    case "link":
       expr = jsonExpr(col, dialect);
       break;
     case "select":
@@ -768,6 +1144,7 @@ function columnExpr(key, field, dialect, table) {
     default:
       expr = `text('${col}')`;
   }
+  if (isUniqueValueField(field)) expr += ".unique()";
   if (isRequiredField(field)) expr += ".notNull()";
   return `  ${key}: ${expr},`;
 }
@@ -863,6 +1240,35 @@ function usersTableExpr(dialect) {
   updatedAt: ${nowExpr(pg, "updated_at")},
 })`;
 }
+function redirectsTableExpr(dialect) {
+  const pg = dialect === "postgres";
+  const tableFn = pg ? "pgTable" : "sqliteTable";
+  return `export const cms_redirects = ${tableFn}('cms_redirects', {
+  id: text('id').primaryKey(),
+  from: text('from_path').notNull().unique(),
+  to: text('to_path').notNull(),
+  status: integer('status').notNull().default(301),
+  keepQuery: ${pg ? `boolean('keep_query')` : `integer('keep_query', { mode: 'boolean' })`}.notNull().default(true),
+  source: text('source').notNull().default('manual'),
+  createdAt: ${nowExpr(pg, "created_at")},
+  updatedAt: ${nowExpr(pg, "updated_at")},
+})`;
+}
+function previewLinksTableExpr(dialect) {
+  const pg = dialect === "postgres";
+  const tableFn = pg ? "pgTable" : "sqliteTable";
+  return `export const cms_preview_links = ${tableFn}('cms_preview_links', {
+  id: text('id').primaryKey(),
+  tokenHash: text('token_hash').notNull().unique(),
+  entry: text('entry').notNull(),
+  itemId: text('item_id').notNull(),
+  locale: text('locale'),
+  createdBy: text('created_by'),
+  createdAt: ${nowExpr(pg, "created_at")},
+  expiresAt: text('expires_at').notNull(),
+  revokedAt: text('revoked_at'),
+})`;
+}
 function mediaTableExpr(dialect) {
   const pg = dialect === "postgres";
   const tableFn = pg ? "pgTable" : "sqliteTable";
@@ -875,6 +1281,8 @@ function mediaTableExpr(dialect) {
   size: integer('size'),
   width: integer('width'),
   height: integer('height'),
+  focalX: ${pg ? `doublePrecision('focal_x')` : `real('focal_x')`},
+  focalY: ${pg ? `doublePrecision('focal_y')` : `real('focal_y')`},
   createdAt: ${nowExpr(pg, "created_at")},
 })`;
 }
@@ -886,12 +1294,11 @@ function renderSchemaFile(config, dialect, resolveImport = (s) => s) {
   const rowsEntries = derived.filter(([, entry]) => entry.kind === "page");
   const pg = dialect === "postgres";
   const core = /* @__PURE__ */ new Set(["integer", "text", pg ? "pgTable" : "sqliteTable"]);
-  if (fields.some((f) => f.type === "number" && !f.integer))
-    core.add(pg ? "doublePrecision" : "real");
+  core.add(pg ? "doublePrecision" : "real");
   if (pg && fields.some((f) => f.type === "date")) core.add("date");
   if (pg) core.add("boolean");
   if (pg && fields.some(
-    (f) => f.type === "json" || f.type === "blocks" || isTranslatableField(f) && !isTranslatableMediaField(f) || isStringListField(f)
+    (f) => f.type === "json" || f.type === "blocks" || f.type === "link" || isTranslatableField(f) && !isTranslatableMediaField(f) || isStringListField(f)
   ))
     core.add("jsonb");
   if (pg) core.add("timestamp");
@@ -919,6 +1326,8 @@ ${[
     mediaTableExpr(dialect),
     settingsTableExpr(dialect),
     usersTableExpr(dialect),
+    redirectsTableExpr(dialect),
+    previewLinksTableExpr(dialect),
     ...tables,
     ...joins,
     ...rows
@@ -926,38 +1335,47 @@ ${[
 `;
 }
 
-const MEDIA_SELECTION = "key url type alt folder mime size width height";
-function blocksSelection(entryName, key, field) {
+const MEDIA_SELECTION = "key url type alt folder mime size width height focalX focalY";
+const LINK_SELECTION = "href label newTab external entry id";
+function fieldSelection(key, field) {
+  if (field.type === "media") return `${key} { ${MEDIA_SELECTION} }`;
+  if (field.type === "link") return `${key} { ${LINK_SELECTION} }`;
+  return key;
+}
+function blocksSelection(entryName, schemaPath, field) {
   const parts = ["__typename type"];
   for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
     const fields = Object.entries(block.fields).map(
-      ([blockFieldKey, blockField]) => blockField.type === "media" ? `${blockFieldKey} { ${MEDIA_SELECTION} }` : blockFieldKey
+      ([blockFieldKey, blockField]) => blockField.type === "blocks" ? `${blockFieldKey} { ${blocksSelection(
+        entryName,
+        [...schemaPath, blockName, blockFieldKey],
+        blockField
+      )} }` : fieldSelection(blockFieldKey, blockField)
     );
     if (!fields.length) continue;
-    parts.push(`... on ${blockTypeName$1(entryName, key, blockName)} { ${fields.join(" ")} }`);
+    parts.push(
+      `... on ${blockTypeName$1(entryName, schemaPath, blockName)} { ${fields.join(" ")} }`
+    );
   }
   return parts.join(" ");
 }
 function entrySelection(config, name, entry, withRelations, fields = entryFieldsFor(entry)) {
   const parts = ["id"];
   if (entry.kind === "page") parts.push("path");
+  if (isRoutedContent(entry)) parts.push("path", "paths { locale path }");
   for (const [key, field] of Object.entries(fields)) {
     if (isPrivateField(field)) continue;
     if (field.type === "relation") {
-      const target = config[field.to];
+      const target = config[relationTarget(field)];
       if (!withRelations || !target) continue;
-      parts.push(`${key} { ${entrySelection(config, field.to, target, false)} }`);
-      continue;
-    }
-    if (field.type === "media") {
-      parts.push(`${key} { ${MEDIA_SELECTION} }`);
+      parts.push(`${key} { ${entrySelection(config, relationTarget(field), target, false)} }`);
       continue;
     }
     if (field.type === "blocks") {
-      parts.push(`${key} { ${blocksSelection(name, key, field)} }`);
+      parts.push(`${key} { ${blocksSelection(name, [key], field)} }`);
       continue;
     }
-    parts.push(key);
+    parts.push(fieldSelection(key, field));
   }
   if (isCollectionKind(entry)) parts.push("createdAt");
   parts.push("updatedAt");
@@ -986,6 +1404,19 @@ function contentItemQuery(config, name, entry) {
   const selection = entrySelection(config, name, entry, true);
   return `query CmsContent($slug: String!, $locale: String) { item: ${name}BySlug(slug: $slug, locale: $locale) { ${selection} } }`;
 }
+function contentRouteQuery(config) {
+  const names = routedContentNames(config);
+  if (!names.length) return null;
+  const fields = names.map(
+    (name) => `${name}: ${name}ByPath(path: $path, locale: $locale) { ${entrySelection(
+      config,
+      name,
+      config[name],
+      true
+    )} }`
+  );
+  return `query CmsRoute($path: String!, $locale: String) { ${fields.join(" ")} }`;
+}
 function pageQuery(config, name, entry, path) {
   const selection = entrySelection(config, name, entry, true, pageFields(entry, path));
   return `query CmsPage($path: String!, $locale: String) { page: ${name}ByPath(path: $path, locale: $locale) { ${selection} } }`;
@@ -1042,6 +1473,10 @@ function renderQueriesFile(config) {
     `export const cmsContentItemQueries: Record<string, string> = {`,
     ...contentItems,
     `}`,
+    ``,
+    `export const cmsRouteEntries: string[] = ${JSON.stringify(routedContentNames(config))}`,
+    ``,
+    `export const cmsRouteQuery: string | null = ${JSON.stringify(contentRouteQuery(config))}`,
     ``
   ].join("\n");
 }
@@ -1066,11 +1501,12 @@ function scalarTsType(field) {
 }
 function fieldTsType(config, entryName, key, field) {
   if (field.type === "relation") {
-    const target = typeName(field.to);
+    const target = typeName(relationTarget(field));
     if (field.cardinality === "many-to-many") return `${target}[]`;
-    return isRequiredField(field) && !config[field.to]?.drafts ? target : `${target} | null`;
+    return isRequiredField(field) && !config[relationTarget(field)]?.drafts ? target : `${target} | null`;
   }
   if (field.type === "media") return `${mediaTsType(field)} | null`;
+  if (field.type === "link") return "CmsLink | null";
   if (field.type === "tags") return "string[]";
   if (field.type === "select" && field.multiple) {
     const union = selectOptionValues(field).map((o) => JSON.stringify(o)).join(" | ");
@@ -1084,20 +1520,32 @@ function fieldTsType(config, entryName, key, field) {
   const base = scalarTsType(field);
   return isRequiredField(field) ? base : `${base} | null`;
 }
-function blockPropsTypeName(entryName, fieldKey, blockName) {
-  return `${blockTypeName$1(entryName, fieldKey, blockName)}Props`;
+function blockPropsTypeName(entryName, schemaPath, blockName) {
+  return `${blockTypeName$1(entryName, schemaPath, blockName)}Props`;
+}
+function blockFieldTs(entryName, schemaPath, blockName, key, field) {
+  if (field.type === "media") return mediaTsType(field);
+  if (field.type === "link") return "CmsLink";
+  if (field.type === "blocks")
+    return `${blocksFieldTypeName(entryName, [...schemaPath, blockName, key])}[]`;
+  return scalarTsType(field);
 }
-function blockTypesTs(entryName, key, field) {
+function blockTypesTs(entryName, schemaPath, field) {
   const defs = [];
+  const nested = [];
   const members = [];
   for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
-    const name = blockTypeName$1(entryName, key, blockName);
-    const props = blockPropsTypeName(entryName, key, blockName);
+    const name = blockTypeName$1(entryName, schemaPath, blockName);
+    const props = blockPropsTypeName(entryName, schemaPath, blockName);
     members.push(name);
     const lines = [];
     for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
-      const base = blockField.type === "media" ? mediaTsType(blockField) : scalarTsType(blockField);
+      const base = blockFieldTs(entryName, schemaPath, blockName, blockFieldKey, blockField);
       lines.push(`  ${blockFieldKey}: ${base} | null`);
+      if (blockField.type === "blocks")
+        nested.push(
+          ...blockTypesTs(entryName, [...schemaPath, blockName, blockFieldKey], blockField)
+        );
     }
     defs.push(`export interface ${props} {
 ${lines.join("\n")}
@@ -1110,12 +1558,15 @@ ${lines.join("\n")}
     );
   }
   if (members.length)
-    defs.push(`export type ${blocksFieldTypeName(entryName, key)} = ${members.join(" | ")}`);
-  return defs;
+    defs.push(
+      `export type ${blocksFieldTypeName(entryName, schemaPath)} = ${members.join(" | ")}`
+    );
+  return [...defs, ...nested];
 }
 function entryTs(config, name, entry) {
   const lines = ["  id: string"];
   if (entry.kind === "page") lines.push("  path: string");
+  if (isRoutedContent(entry)) lines.push("  path: string", "  paths: CmsLocalePath[]");
   for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
     if (isPrivateField(field)) continue;
     lines.push(`  ${key}: ${fieldTsType(config, name, key, field)}`);
@@ -1144,9 +1595,9 @@ function autoTypeTs(config, name, entry) {
   if (!keys.length) return `export type ${auto} = ${typeName(name)}`;
   const lines = keys.map((key) => {
     const field = entry.fields[key];
-    const shallow = shallowTypeTs(config, field.to);
+    const shallow = shallowTypeTs(config, relationTarget(field));
     if (field.cardinality === "many-to-many") return `  ${key}: ${shallow}[]`;
-    const nonNull = isRequiredField(field) && !config[field.to]?.drafts;
+    const nonNull = isRequiredField(field) && !config[relationTarget(field)]?.drafts;
     return `  ${key}: ${shallow}${nonNull ? "" : " | null"}`;
   });
   return `export type ${auto} = Omit<${typeName(name)}, ${quotedKeys(keys)}> & {
@@ -1185,6 +1636,7 @@ function entryMapsTs(config) {
     else if (entry.kind === "content") contents.push(line);
     else collections.push(line);
   }
+  const routed = routedContentNames(config);
   if (!pages.length) {
     pages.push(
       `export interface CmsPageTypes {
@@ -1206,6 +1658,12 @@ ${contents.join("\n")}
     `export type CmsSingleName = keyof CmsSingleTypes`,
     `export type CmsCollectionName = keyof CmsCollectionTypes`,
     `export type CmsContentName = keyof CmsContentTypes`,
+    `export type CmsRoutedContentName = ${routed.length ? quotedKeys(routed) : "never"}`,
+    [
+      `export type CmsContentRouteMatch = {`,
+      `  [K in CmsRoutedContentName]: { entry: K; item: CmsContentTypes[K] }`,
+      `}[CmsRoutedContentName]`
+    ].join("\n"),
     ...pages
   ];
 }
@@ -1213,15 +1671,21 @@ function blockPropsMapTs(config) {
   const entries = [];
   for (const [name, entry] of Object.entries(config)) {
     const fields = [];
-    for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
-      if (field.type !== "blocks" || isPrivateField(field)) continue;
+    for (const { field, schemaPath } of blocksFieldPaths(entryFieldsFor(entry))) {
+      if (isPrivateField(field)) continue;
       const blocks = Object.keys(field.blocks ?? {}).map(
-        (blockName) => `      ${JSON.stringify(blockName)}: ${blockPropsTypeName(name, key, blockName)}`
+        (blockName) => `      ${JSON.stringify(blockName)}: ${blockPropsTypeName(
+          name,
+          schemaPath,
+          blockName
+        )}`
       );
       if (blocks.length)
-        fields.push(`    ${JSON.stringify(key)}: {
+        fields.push(
+          `    ${JSON.stringify(schemaPath.join("."))}: {
 ${blocks.join("\n")}
-    }`);
+    }`
+        );
     }
     if (fields.length) entries.push(`  ${JSON.stringify(name)}: {
 ${fields.join("\n")}
@@ -1245,7 +1709,19 @@ ${entries.join("\n")}
 }
 function renderTypesFile(config) {
   const parts = [
+    `export interface CmsLocalePath {
+  locale: string
+  path: string
+}`,
     `export type CmsMediaType = 'image' | 'video' | 'file'`,
+    `export interface CmsLink {
+  href: string | null
+  label: string | null
+  newTab: boolean
+  external: boolean
+  entry: string | null
+  id: string | null
+}`,
     `export interface CmsMedia<T extends CmsMediaType = CmsMediaType> {
   key: string
   url: string | null
@@ -1256,12 +1732,14 @@ function renderTypesFile(config) {
   size: number | null
   width: number | null
   height: number | null
+  focalX: number | null
+  focalY: number | null
 }`
   ];
   for (const [name, entry] of Object.entries(config)) {
     for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
-        parts.push(...blockTypesTs(name, key, field));
+        parts.push(...blockTypesTs(name, [key], field));
     }
     parts.push(entryTs(config, name, entry));
   }
@@ -1282,6 +1760,107 @@ function resolveCmsEnabled(explicit, envValue) {
   return true;
 }
 
+const DEFAULT_WEBHOOK_TIMEOUT = 5e3;
+const MAX_WEBHOOK_TIMEOUT = 3e4;
+const MIN_WEBHOOK_SECRET_LENGTH = 16;
+const WEBHOOK_KEYS = /* @__PURE__ */ new Set(["name", "url", "secret", "events", "timeout"]);
+const WEBHOOK_NAME_PATTERN = /^[a-z]+(?:[A-Z][a-z]+)*[0-9]*$/;
+const WEBHOOK_EVENT_FILTERS = [
+  "entry",
+  "media",
+  ...CMS_ENTRY_ACTIONS.map((action) => `entry:${action}`),
+  ...CMS_MEDIA_ACTIONS.map((action) => `media:${action}`)
+];
+function webhookEnvName(name, key) {
+  return `NUXT_CMS_WEBHOOKS_${name.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase()}_${key.toUpperCase()}`;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function urlError(label, url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") return null;
+  } catch {
+    return `${label}.url '${url}' is not a valid URL`;
+  }
+  return `${label}.url '${url}' must use http or https`;
+}
+function resolveWebhooks(input, env = {}) {
+  const webhooks = {};
+  const errors = [];
+  const warnings = [];
+  if (input === void 0) return { webhooks, errors, warnings };
+  if (!Array.isArray(input)) {
+    return {
+      webhooks,
+      errors: ["webhooks must be an array of { name, url, secret, events }"],
+      warnings
+    };
+  }
+  input.forEach((item, index) => {
+    const label = `webhooks[${index}]`;
+    if (!isRecord(item)) {
+      errors.push(`${label} must be an object`);
+      return;
+    }
+    for (const key of Object.keys(item)) {
+      if (!WEBHOOK_KEYS.has(key)) errors.push(`${label} has an unknown key '${key}'`);
+    }
+    const { name, url, secret, events, timeout } = item;
+    if (typeof name !== "string" || !WEBHOOK_NAME_PATTERN.test(name)) {
+      errors.push(
+        `${label}.name must be a camelCase identifier like 'deploy' or 'searchIndex', got ${JSON.stringify(
+          name
+        )}`
+      );
+      return;
+    }
+    const named = `webhooks '${name}'`;
+    if (Object.hasOwn(webhooks, name)) {
+      errors.push(`${named} is declared twice`);
+      return;
+    }
+    if (url !== void 0 && typeof url !== "string") errors.push(`${named}.url must be a string`);
+    else if (url) {
+      const error = urlError(named, url);
+      if (error) errors.push(error);
+    } else if (!env[webhookEnvName(name, "url")]) {
+      warnings.push(
+        `${named} has no url: set ${webhookEnvName(name, "url")} at runtime or it never fires`
+      );
+    }
+    if (secret !== void 0 && typeof secret !== "string")
+      errors.push(`${named}.secret must be a string`);
+    else if (secret && secret.length < MIN_WEBHOOK_SECRET_LENGTH)
+      errors.push(`${named}.secret must be at least ${MIN_WEBHOOK_SECRET_LENGTH} characters`);
+    if (events !== void 0) {
+      if (!Array.isArray(events) || !events.length) {
+        errors.push(`${named}.events must be a non-empty array (omit it for every event)`);
+      } else {
+        for (const value of events) {
+          if (!WEBHOOK_EVENT_FILTERS.includes(value))
+            errors.push(
+              `${named}.events has an unknown event ${JSON.stringify(
+                value
+              )}: use 'entry', 'media', 'entry:<action>' or 'media:<action>'`
+            );
+        }
+      }
+    }
+    if (timeout !== void 0 && (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > MAX_WEBHOOK_TIMEOUT)) {
+      errors.push(`${named}.timeout must be an integer between 1 and ${MAX_WEBHOOK_TIMEOUT} ms`);
+    }
+    webhooks[name] = {
+      url: typeof url === "string" ? url : "",
+      secret: typeof secret === "string" ? secret : "",
+      events: Array.isArray(events) ? [...new Set(events)] : [],
+      timeout: typeof timeout === "number" ? timeout : DEFAULT_WEBHOOK_TIMEOUT
+    };
+  });
+  return { webhooks, errors, warnings };
+}
+
 function resolveDatabaseOptions(database) {
   const shared = {
     migrateOnBoot: database?.migrateOnBoot ?? true,
@@ -1312,6 +1891,9 @@ function resolveDatabaseOptions(database) {
   }
   return { ...shared, driver: "sqlite", path: database?.path ?? "data/cms.db" };
 }
+const MODULE_VERSION = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+).version;
 const DEFAULT_FILESYSTEM_MEDIA_DIR = "data/media";
 const DEFAULT_FILESYSTEM_MEDIA_BASE_URL = "/media";
 function resolveMediaOptions(media) {
@@ -1377,11 +1959,69 @@ function resolveModuleOptions(options) {
     },
     preview: {
       path: options.preview?.path ?? DEFAULT_CMS_PREVIEW_PATH,
-      component: options.preview?.component?.trim() ?? ""
+      component: options.preview?.component?.trim() ?? "",
+      banner: options.preview?.banner ?? true
     }
   };
 }
 const moduleRequire = createRequire(import.meta.url);
+function resolveSiteUrlOption(nuxt, options) {
+  const existing = nuxt.options.runtimeConfig.public.siteUrl;
+  const nuxtSite = nuxt.options.site?.url;
+  const candidates = [
+    options.site?.url,
+    typeof existing === "string" ? existing : void 0,
+    typeof nuxtSite === "string" ? nuxtSite : void 0,
+    process.env.NUXT_PUBLIC_SITE_URL
+  ];
+  return normalizeSiteUrl(candidates.find((candidate) => candidate?.trim()));
+}
+function setupSiteUrl(nuxt, options, logger) {
+  const errors = seoOptionErrors(options.seo, options.site);
+  if (errors.length) throw new Error(`[nuxt-cms] ${errors.join("\n")}`);
+  const existing = nuxt.options.runtimeConfig.public.siteUrl;
+  const siteUrl = resolveSiteUrlOption(nuxt, options);
+  if (options.site?.url && typeof existing === "string" && existing.trim() && normalizeSiteUrl(existing) !== siteUrl) {
+    logger.warn(
+      `[nuxt-cms] cms.site.url (${siteUrl}) replaces runtimeConfig.public.siteUrl (${existing}).`
+    );
+  }
+  nuxt.options.runtimeConfig.public.siteUrl = siteUrl;
+  nuxt.options.runtimeConfig.public.cmsTrustForwardedHost = options.site?.trustForwardedHost === true;
+}
+function setupSeoRoutes(nuxt, resolver, seo, publicDir, logger) {
+  nuxt.hook("modules:done", () => {
+    const installed = (names) => names.filter((name) => hasNuxtModule(name, nuxt));
+    const publicFile = (file) => existsSync(join(publicDir, file)) ? [`public/${file}`] : [];
+    const sitemapConflicts = [
+      ...installed(SITEMAP_CONFLICT_MODULES),
+      ...publicFile(SITEMAP_PATH.slice(1))
+    ];
+    const switches = resolveSeoSwitches(seo, {
+      sitemap: sitemapConflicts,
+      robots: [...installed(ROBOTS_CONFLICT_MODULES), ...publicFile(ROBOTS_PATH.slice(1))]
+    });
+    for (const warning of switches.warnings) logger.warn(warning);
+    const siteUrlWarning = nuxt.options.runtimeConfig.public.siteUrl ? null : missingSiteUrlWarning(switches);
+    if (siteUrlWarning && !nuxt.options.dev) logger.warn(siteUrlWarning);
+    const runtime = nuxt.options.runtimeConfig.cms;
+    runtime.seo = {
+      sitemap: switches.sitemap,
+      robots: switches.robots,
+      robotsSitemap: switches.sitemap || sitemapConflicts.length > 0
+    };
+    if (switches.sitemap)
+      addServerHandler({
+        route: SITEMAP_PATH,
+        handler: resolver.resolve("./runtime/server/routes/sitemap")
+      });
+    if (switches.robots)
+      addServerHandler({
+        route: ROBOTS_PATH,
+        handler: resolver.resolve("./runtime/server/routes/robots")
+      });
+  });
+}
 function resolveImport(specifier) {
   try {
     return fileURLToPath(import.meta.resolve(specifier)).replace(/\\/g, "/");
@@ -1528,6 +2168,30 @@ function addCmsBlocks(nuxt, resolver, cmsConfig, previewComponent) {
     name: "CmsBlocks",
     filePath: resolver.resolve("./runtime/app/blocks/CmsBlocks.vue")
   });
+  addComponent({
+    name: "CmsLink",
+    filePath: resolver.resolve("./runtime/app/links/CmsLink.vue")
+  });
+  addComponent({
+    name: "CmsField",
+    filePath: resolver.resolve("./runtime/app/blocks/CmsField")
+  });
+  addPlugin(resolver.resolve("./runtime/app/plugins/cms-field"));
+  addTypeTemplate({
+    filename: "types/nuxt-cms-field.d.ts",
+    getContents: () => [
+      "import type { Directive } from 'vue'",
+      "",
+      "declare module 'vue' {",
+      "  interface GlobalDirectives {",
+      "    vCmsField: Directive<HTMLElement, string>",
+      "  }",
+      "}",
+      "",
+      "export {}",
+      ""
+    ].join("\n")
+  });
   if (!refs.length && !previews.length) return;
   nuxt.hook("components:extend", (components) => {
     const names = components.map((component) => component.pascalName);
@@ -1540,6 +2204,23 @@ function addCmsBlocks(nuxt, resolver, cmsConfig, previewComponent) {
 ${errors.join("\n")}`);
   });
 }
+function addCmsImage(nuxt, resolver) {
+  const imageTemplate = addTemplate({
+    filename: "cms/image.ts",
+    write: true,
+    getContents: () => renderImageFile(
+      resolveCmsImageSetup(
+        hasNuxtModule("@nuxt/image", nuxt),
+        nuxt.options
+      )
+    )
+  });
+  nuxt.options.alias["#cms-image"] = imageTemplate.dst;
+  addComponent({
+    name: "CmsImage",
+    filePath: resolver.resolve("./runtime/app/image/CmsImage.vue")
+  });
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "@xleddyl/nuxt-cms",
@@ -1602,6 +2283,13 @@ const module$1 = defineNuxtModule({
     const resolver = createResolver(import.meta.url);
     const logger = useLogger("nuxt-cms");
     const resolved = resolveModuleOptions(options);
+    const webhooks = resolveWebhooks(options.webhooks, process.env);
+    if (webhooks.errors.length) {
+      throw new Error(`[nuxt-cms] Invalid webhooks:
+${webhooks.errors.join("\n")}`);
+    }
+    for (const warning of webhooks.warnings) logger.warn(`[nuxt-cms] ${warning}`);
+    setupSiteUrl(nuxt, options, logger);
     if (!resolveCmsEnabled(options.enabled, process.env[CMS_ENABLED_ENV])) {
       const queryStub = resolver.resolve("./runtime/app/composables/cms-query-disabled");
       const entryStub = resolver.resolve("./runtime/app/composables/cms-entry-disabled");
@@ -1612,7 +2300,17 @@ const module$1 = defineNuxtModule({
         { name: "useCmsCollection", from: entryStub },
         { name: "useCmsPage", from: entryStub },
         { name: "useCmsContents", from: entryStub },
-        { name: "useCmsContent", from: entryStub }
+        { name: "useCmsContent", from: entryStub },
+        { name: "useCmsRoute", from: entryStub },
+        {
+          name: "useCmsSite",
+          from: resolver.resolve("./runtime/app/composables/cms-site-disabled")
+        },
+        { name: "useCmsSeo", from: resolver.resolve("./runtime/app/composables/cms-seo") },
+        {
+          name: "useCmsPreviewMode",
+          from: resolver.resolve("./runtime/app/composables/cms-preview-mode")
+        }
       ]);
       const disabledConfig = await loadCmsConfig(
         nuxt,
@@ -1623,12 +2321,14 @@ const module$1 = defineNuxtModule({
       );
       addCmsTypeTemplates(nuxt, disabledConfig);
       addCmsBlocks(nuxt, resolver, disabledConfig, resolved.preview.component);
+      addCmsImage(nuxt, resolver);
       nuxt.options.runtimeConfig.public.cms = {
         mediaBaseUrl: resolved.media.publicBaseUrl,
         mediaStorage: resolved.media.storage,
         mediaMaxFileSize: resolved.media.maxFileSize,
         i18n: resolved.i18n,
-        previewPath: resolved.preview.path
+        previewPath: resolved.preview.path,
+        version: MODULE_VERSION
       };
       logger.info(
         "[nuxt-cms] disabled: registering no-op query composables and generated types, skipping admin, server and database setup"
@@ -1674,19 +2374,61 @@ const module$1 = defineNuxtModule({
     });
     nuxt.options.alias["#cms-tables"] = schemaTemplate.dst;
     addCmsTypeTemplates(nuxt, cmsConfig);
+    const roles = validateRoles(options.roles, cmsConfig);
+    if (roles.errors.length) {
+      for (const error of roles.errors) logger.error(error);
+      throw new Error(
+        `[nuxt-cms] Invalid cms.roles (${roles.errors.length} error${roles.errors.length > 1 ? "s" : ""})`
+      );
+    }
+    for (const warning of roles.warnings) logger.warn(`[nuxt-cms] ${warning}`);
+    const rolesTypes = resolver.resolve("./runtime/shared/roles").replace(/\\/g, "/");
+    addTemplate({
+      filename: "cms/roles.d.ts",
+      write: true,
+      getContents: () => [
+        `import type { CmsRoles } from '${rolesTypes}'`,
+        ``,
+        `declare const roles: CmsRoles`,
+        ``,
+        `export default roles`,
+        ``
+      ].join("\n")
+    });
+    const rolesTemplate = addTemplate({
+      filename: "cms/roles.js",
+      write: true,
+      getContents: () => `export default ${JSON.stringify(roles.roles, null, 3)}
+`
+    });
+    nuxt.options.alias["#cms-roles"] = rolesTemplate.dst;
     const queryComposables = resolver.resolve("./runtime/app/composables/cms-query");
     const entryComposables = resolver.resolve("./runtime/app/composables/cms-entry");
     addImports([
+      { name: "useCmsSite", from: resolver.resolve("./runtime/app/composables/cms-site") },
+      { name: "useCmsSeo", from: resolver.resolve("./runtime/app/composables/cms-seo") },
       { name: "useCms", from: queryComposables },
       { name: "$cmsQuery", from: queryComposables },
       { name: "useCmsSingle", from: entryComposables },
       { name: "useCmsCollection", from: entryComposables },
       { name: "useCmsPage", from: entryComposables },
       { name: "useCmsContents", from: entryComposables },
-      { name: "useCmsContent", from: entryComposables }
+      { name: "useCmsContent", from: entryComposables },
+      { name: "useCmsRoute", from: entryComposables },
+      {
+        name: "useCmsPreviewMode",
+        from: resolver.resolve("./runtime/app/composables/cms-preview-mode")
+      }
     ]);
     addCmsBlocks(nuxt, resolver, cmsConfig, resolved.preview.component);
-    const previewErrors = previewPathErrors(resolved.preview.path, Object.keys(cmsConfig));
+    addCmsImage(nuxt, resolver);
+    addPlugin(resolver.resolve("./runtime/app/plugins/cms-preview"));
+    if (resolved.preview.banner)
+      addPlugin(resolver.resolve("./runtime/app/plugins/cms-preview-banner.client"));
+    const previewErrors = [
+      ...previewPathErrors(resolved.preview.path, Object.keys(cmsConfig)),
+      ...previewBannerErrors(options.preview?.banner)
+    ];
     if (previewErrors.length) throw new Error(`[nuxt-cms] ${previewErrors.join("\n")}`);
     const previewPath = resolved.preview.path;
     const previewRule = nuxt.options.routeRules?.[previewPath] ?? {};
@@ -1729,6 +2471,16 @@ const module$1 = defineNuxtModule({
     const relativeSchemaPath = relative(nuxt.options.rootDir, schemaTemplate.dst);
     const relativeMigrationsDir = relative(nuxt.options.rootDir, migrationsDir);
     const toPosix = (path) => path.replace(/\\/g, "/");
+    const migrationFixes = {
+      dialect,
+      out: toPosix(migrationsDir),
+      uniqueTextColumns: uniqueTextColumns(cmsConfig)
+    };
+    addTemplate({
+      filename: `cms/${MIGRATION_FIXES_FILE}`,
+      write: true,
+      getContents: () => JSON.stringify(migrationFixes, null, 2)
+    });
     addTemplate({
       filename: "cms/drizzle.config.ts",
       write: true,
@@ -1803,6 +2555,9 @@ const module$1 = defineNuxtModule({
       )
     );
     addServerPlugin(resolver.resolve("./runtime/server/plugins/session-validate"));
+    if (Object.keys(webhooks.webhooks).length) {
+      addServerPlugin(resolver.resolve("./runtime/server/plugins/webhooks"));
+    }
     if (!nuxt.options.dev) {
       addServerPlugin(resolver.resolve("./runtime/server/plugins/session-check"));
     }
@@ -1819,11 +2574,22 @@ const module$1 = defineNuxtModule({
           `--schema=${relativeSchemaPath}`,
           `--out=${relativeMigrationsDir}`
         ];
+        const before = migrationSqlFiles(migrationsDir);
         const code = await new Promise((done) => {
           spawn(process.execPath, args, { cwd: nuxt.options.rootDir, stdio: "inherit" }).on("close", (exitCode) => done(exitCode ?? 1)).on("error", () => done(1));
         });
-        if (code !== 0)
+        if (code !== 0) {
           logger.error(`[nuxt-cms] drizzle-kit generate failed (exit code ${code})`);
+          return;
+        }
+        const fixed = fixNewMigrations(
+          migrationsDir,
+          before,
+          migrationFixes.uniqueTextColumns,
+          dialect
+        );
+        for (const file of fixed)
+          logger.info(`[nuxt-cms] ${file}: blank values of new unique fields become NULL`);
       });
     }
     const mediaFilesystemBase = resolved.media.storage === "filesystem" ? `/${resolved.media.publicBaseUrl.split("/").filter(Boolean).join("/")}` : "";
@@ -1867,14 +2633,20 @@ const module$1 = defineNuxtModule({
         localRoot: mediaLocalRoot,
         dir: mediaDir,
         ...existingConfig.media ?? {}
-      }
+      },
+      webhooks: {
+        ...webhooks.webhooks,
+        ...existingConfig.webhooks ?? {}
+      },
+      seo: { sitemap: false, robots: false, robotsSitemap: false }
     };
     nuxt.options.runtimeConfig.public.cms = {
       mediaBaseUrl: resolved.media.publicBaseUrl,
       mediaStorage: resolved.media.storage,
       mediaMaxFileSize: resolved.media.maxFileSize,
       i18n: resolved.i18n,
-      previewPath
+      previewPath,
+      version: MODULE_VERSION
     };
     addTypeTemplate(
       {
@@ -1887,7 +2659,7 @@ const module$1 = defineNuxtModule({
           "    id?: string",
           "    email: string",
           "    name?: string | null",
-          "    role?: 'superadmin' | 'admin'",
+          "    role?: string",
           "    firstLogin?: boolean",
           "    passwordStamp?: string",
           "  }",
@@ -1913,6 +2685,25 @@ const module$1 = defineNuxtModule({
       },
       { nuxt: true, nitro: true }
     );
+    const hooksTypes = toPosix(resolver.resolve("./runtime/shared/hooks"));
+    addTypeTemplate(
+      {
+        filename: "types/nuxt-cms-hooks.d.ts",
+        getContents: () => [
+          `import type { CmsRuntimeHooks } from '${hooksTypes}'`,
+          "",
+          ...["nitropack", "nitropack/types"].flatMap((name) => [
+            `declare module '${name}' {`,
+            "  interface NitroRuntimeHooks extends CmsRuntimeHooks {}",
+            "}",
+            ""
+          ]),
+          "export {}",
+          ""
+        ].join("\n")
+      },
+      { nuxt: true, nitro: true }
+    );
     const brandPaths = {
       rootDir: nuxt.options.rootDir,
       srcDir: nuxt.options.srcDir ?? nuxt.options.rootDir
@@ -1944,12 +2735,12 @@ const module$1 = defineNuxtModule({
       );
     });
     nuxt.hook("modules:done", async () => {
-      const include = nuxt.options.vite.optimizeDeps?.include;
-      if (!include) return;
+      const optimizeDeps = nuxt.options.vite.optimizeDeps ??= {};
+      const include = [.../* @__PURE__ */ new Set([...optimizeDeps.include ?? [], "zod"])];
       const rootUrl = pathToFileURL(`${nuxt.options.rootDir}/`).href;
-      nuxt.options.vite.optimizeDeps.include = await Promise.all(
+      optimizeDeps.include = await Promise.all(
         include.map(
-          async (entry) => entry.startsWith("@tiptap/") && !await tryResolveModule(entry, rootUrl) ? `@xleddyl/nuxt-cms > ${entry}` : entry
+          async (entry) => (entry.startsWith("@tiptap/") || entry === "zod") && !await tryResolveModule(entry, rootUrl) ? `@xleddyl/nuxt-cms > ${entry}` : entry
         )
       );
     });
@@ -2092,6 +2883,11 @@ const module$1 = defineNuxtModule({
         handler: resolver.resolve("./runtime/server/routes/media-file")
       });
     }
+    addServerHandler({
+      route: "/api/cms/link-usage",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/link-usage.post")
+    });
     addServerHandler({
       route: "/api/cms/search",
       method: "get",
@@ -2132,6 +2928,74 @@ const module$1 = defineNuxtModule({
       method: "post",
       handler: resolver.resolve("./runtime/server/api/account-welcome.post")
     });
+    addServerHandler({
+      route: "/api/cms/site",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/site.get")
+    });
+    addServerHandler({
+      route: "/api/cms/site",
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/site.put")
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolver.resolve("./runtime/server/middleware/hidden-site")
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolver.resolve("./runtime/server/middleware/redirects")
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolver.resolve("./runtime/server/middleware/preview-links")
+    });
+    addServerHandler({
+      route: "/api/cms/preview",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/preview.get")
+    });
+    addServerHandler({
+      route: "/api/cms/preview-links/:collection/:id",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/preview-links.get")
+    });
+    addServerHandler({
+      route: "/api/cms/preview-links/:collection/:id",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/preview-links.post")
+    });
+    addServerHandler({
+      route: "/api/cms/preview-links/:collection/:id/:linkId",
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/preview-link.delete")
+    });
+    addServerHandler({
+      route: "/api/cms/redirects",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/redirects.get")
+    });
+    addServerHandler({
+      route: "/api/cms/redirects",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/redirects.post")
+    });
+    addServerHandler({
+      route: "/api/cms/redirects/import",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/redirects-import.post")
+    });
+    addServerHandler({
+      route: "/api/cms/redirects/:id",
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/redirect.put")
+    });
+    addServerHandler({
+      route: "/api/cms/redirects/:id",
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/redirect.delete")
+    });
+    setupSeoRoutes(nuxt, resolver, options.seo, publicDir, logger);
     addServerHandler({
       route: "/api/cms/admin/settings",
       method: "get",
@@ -2147,6 +3011,31 @@ const module$1 = defineNuxtModule({
       method: "delete",
       handler: resolver.resolve("./runtime/server/api/settings.delete")
     });
+    addServerHandler({
+      route: "/api/cms/presets",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/presets.get")
+    });
+    addServerHandler({
+      route: "/api/cms/presets/:id",
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/preset.put")
+    });
+    addServerHandler({
+      route: "/api/cms/presets/:id",
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/preset.delete")
+    });
+    addServerHandler({
+      route: "/api/cms/presets/:collection/:field",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/presets-field.get")
+    });
+    addServerHandler({
+      route: "/api/cms/presets/:collection/:field",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/presets-field.post")
+    });
     addServerHandler({
       route: "/api/cms/tags/:collection/:field",
       method: "get",