@aduptive/strapi-blockscene 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/server.cjs

@@ -21,6 +21,10 @@ var require_groups = __commonJS({
       return Object.keys(out).length ? out : null;
     }
     var uidOf = (row) => typeof row?.__component === "string" ? row.__component : "";
+    var invalidComponents2 = (rows, allowed) => {
+      const uids = new Set(Array.isArray(allowed) ? allowed : []);
+      return (Array.isArray(rows) ? rows : []).flatMap((row, index) => uidOf(row) && !uids.has(uidOf(row)) ? [{ index, uid: uidOf(row) }] : []);
+    };
     var isOpener = (row, g) => Boolean(g) && Object.prototype.hasOwnProperty.call(g, uidOf(row));
     var isClose = (row, g) => Boolean(g) && Object.values(g).includes(uidOf(row));
     var blockKey = (row) => row && row.id != null ? `${row.__component}#${row.id}` : row && row.__temp_key__ != null ? String(row.__temp_key__) : null;
@@ -106,7 +110,42 @@ var require_groups = __commonJS({
       const [, end] = groupRange(rows, start, g);
       return [...rows.slice(0, start), ...rows.slice(end + 1)];
     }
-    module2.exports = { safeGroups: safeGroups2, validateGroups: validateGroups2, groupRange, groupRows, topLevelRanges, moveGroup, removeGroup, blockKey, isOpener, isClose };
+    var MAX_COLUMNS = 12;
+    var parseColumns = (value) => {
+      const n = typeof value === "number" ? value : typeof value === "string" && /^\s*\d{1,3}\s*$/.test(value) ? Number(value) : NaN;
+      return Number.isInteger(n) && n >= 1 ? n : null;
+    };
+    var columnsAttribute = (attr) => Boolean(attr) && typeof attr === "object" && !attr.private && (["integer", "biginteger", "float", "decimal", "string"].includes(attr.type) || attr.type === "enumeration" && Array.isArray(attr.enum) && attr.enum.length > 0 && attr.enum.every((value) => parseColumns(value) !== null));
+    var layoutFields2 = (schema) => Object.entries(schema?.attributes || {}).filter(([, attr]) => columnsAttribute(attr)).map(([name]) => name);
+    function validLayout(value, attributes) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+      if (!Object.keys(value).every((key) => ["columnsField", "mobileColumnsField", "maxColumns"].includes(key))) return false;
+      const field = (name) => typeof name === "string" && /^[A-Za-z_][\w-]{0,63}$/.test(name) && (!attributes || columnsAttribute(attributes[name]));
+      return field(value.columnsField) && (value.mobileColumnsField === void 0 || field(value.mobileColumnsField)) && (value.maxColumns === void 0 || Number.isInteger(value.maxColumns) && value.maxColumns >= 1 && value.maxColumns <= MAX_COLUMNS);
+    }
+    function layoutColumns(row, layout, schema) {
+      const max = layout.maxColumns || MAX_COLUMNS;
+      const read = (name) => Math.min(max, parseColumns(row?.[name]) ?? parseColumns(schema?.attributes?.[name]?.default) ?? 1);
+      return { desktop: read(layout.columnsField), mobile: layout.mobileColumnsField ? read(layout.mobileColumnsField) : null };
+    }
+    module2.exports = {
+      safeGroups: safeGroups2,
+      validateGroups: validateGroups2,
+      invalidComponents: invalidComponents2,
+      groupRange,
+      groupRows,
+      topLevelRanges,
+      moveGroup,
+      removeGroup,
+      blockKey,
+      isOpener,
+      isClose,
+      MAX_COLUMNS,
+      parseColumns,
+      layoutFields: layoutFields2,
+      validLayout,
+      layoutColumns
+    };
   }
 });
 
@@ -118,6 +157,7 @@ var require_settings = __commonJS({
     var TEMPLATES2 = ["generic", "banner", "cards", "imageText", "faq", "none"];
     var INITIAL_STATES = ["closed", "open", "remember"];
     var PREVIEW_MODES = ["form", "split", "preview"];
+    var HIDDEN_MODES = ["strip", "flag", "off"];
     var DEFAULTS2 = {
       palette: { background: "#F6F6F9", surface: "#DCDCE4", text: "#32324D", accent: "#4945FF" },
       components: {},
@@ -125,13 +165,118 @@ var require_settings = __commonJS({
       // blockPreviewInForm: compact read-only preview above a block's fields in form
       // mode. Only installations that ship the accordion integration (server config
       // `blockPreview: true`) show and honour it; the page preview is the editor.
-      editor: { enabled: true, showOpenAll: true, showCloseAll: true, initialState: "closed", previewMode: "form", previewUrl: "", blockPreviewInForm: false }
+      editor: {
+        enabled: true,
+        showOpenAll: true,
+        showCloseAll: true,
+        showRowThumbnails: true,
+        initialState: "closed",
+        previewMode: "form",
+        previewUrl: "",
+        blockPreviewUrl: "",
+        blockPreviewInForm: false,
+        // Strapi 5: rich-text custom fields render a read-only preview until clicked (see admin/LazyInput.tsx).
+        lazyEditors: true,
+        lazyFields: ["plugin::ckeditor5.CKEditor"],
+        // Row actions in each block header (see README "Row actions"). hiddenBlocks: what the content API does with rows
+        // hidden on the site: 'strip' removes them, 'flag' sends them with the attribute, 'off' hides the eye icon.
+        confirmDelete: true,
+        hiddenBlocks: "strip",
+        duplicate: true,
+        clipboard: true,
+        // Edit view labels that are still the raw attribute name read as "Mobile columns count" (see README "Field labels").
+        friendlyLabels: true,
+        // Page preview pane (Strapi 5): which toolbar controls show, in order, and the width menu's entries.
+        previewToolbar: ["modes", "history", "devices", "status", "actions"],
+        previewDevices: ["fit", "mobile", "tablet", "desktop"]
+      },
+      // Per content type (only the ones with a Dynamic Zone): { enabled: false } turns the plugin off there;
+      // previewMode overrides editor.previewMode as the mode the edit view opens in. Absent means the global behaviour.
+      contentTypes: {},
+      // Version history (Strapi 5, see README "Version history"): off until turned on. contentTypes: 'all' (every api:: type)
+      // or a list of uids. Snapshots are kept retentionDays and at most maxSnapshots per document; events eventDays; deleted
+      // documents stay in the trash trashDays (fixed per document when it is deleted).
+      history: { enabled: false, contentTypes: "all", retentionDays: 90, maxSnapshots: 100, eventDays: 365, trashDays: 90 }
     };
+    var ICONS = ["text", "tag", "seo", "settings", "image", "link", "palette", "list", "globe", "info"];
+    var SIDEBAR_POSITIONS = ["left", "right", "bottom"];
+    var OPENS = ["modal", "drawer"];
+    var LABEL = /^[^<>]{1,40}$/;
+    var TOOLBAR = ["modes", "history", "devices", "status", "actions"];
+    var DEVICE_NAMES = ["fit", "mobile", "tablet", "desktop"];
+    var previewToolbar = (value) => Array.isArray(value) && value.every((id) => TOOLBAR.includes(id)) && new Set(value).size === value.length;
+    var DEVICE_LABEL = /^[^<>]{1,24}$/;
+    var customDevice = (item) => item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).every((key) => ["label", "width"].includes(key)) && typeof item.label === "string" && DEVICE_LABEL.test(item.label.trim()) && Number.isInteger(item.width) && item.width >= 240 && item.width <= 3840;
+    var previewDevices = (value) => Array.isArray(value) && value.length >= 1 && value.length <= 8 && value.every((item) => DEVICE_NAMES.includes(item) || customDevice(item)) && new Set(value.map((item) => typeof item === "string" ? item : item.width)).size === value.length;
+    var cleanDevices = (value) => value.map((item) => typeof item === "string" ? item : { label: item.label.trim(), width: item.width });
+    var sidebarItem = (item, attributes) => item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).every((key) => ["label", "icon", "open", "fields"].includes(key)) && typeof item.label === "string" && LABEL.test(item.label.trim()) && (item.icon === void 0 || item.icon === "" || ICONS.includes(item.icon)) && OPENS.includes(item.open) && Array.isArray(item.fields) && item.fields.length > 0 && item.fields.length <= 30 && item.fields.every((field) => typeof field === "string" && (!attributes || attributes.includes(field)));
+    var TYPE_KEYS = {
+      enabled: (value) => typeof value === "boolean",
+      previewMode: (value) => PREVIEW_MODES.includes(value),
+      sidebarPosition: (value) => SIDEBAR_POSITIONS.includes(value),
+      previewToolbar,
+      previewDevices,
+      sidebar: (value, attributes) => Array.isArray(value) && value.length <= 12 && value.every((item) => sidebarItem(item, attributes))
+    };
+    var typeMap = (types) => Array.isArray(types) ? Object.fromEntries(types.map((uid) => [uid, null])) : types || {};
     var PREVIEW_URL = /^https?:\/\/[^\s"'<>]{1,500}$/;
+    var blockPreviewUrl = (value) => typeof value === "string" && (value === "" || PREVIEW_URL.test(value) && !/[{}]/.test(value.replace(/\{(uid|name|category|variant|locale)\}/g, "")) && URL.canParse?.(value.replace(/[{}]/g, "")) !== false);
     var COLOR = /^#[0-9A-Fa-f]{6}$/;
+    var FIELD_UID = /^(plugin|global)::[\w.-]+$/;
+    var lazyFields = (value) => Array.isArray(value) && value.length <= 20 && value.every((uid) => typeof uid === "string" && FIELD_UID.test(uid));
     var UID = /^[a-z0-9-]+\.[a-z0-9-]+$/;
+    var API_UID = /^api::[\w-]+\.[\w-]+$/;
+    var days = (value) => Number.isInteger(value) && value >= 1 && value <= 3650;
+    var HISTORY_KEYS = {
+      enabled: (value) => typeof value === "boolean",
+      contentTypes: (value, uids) => value === "all" || Array.isArray(value) && value.length <= 500 && value.every((uid) => typeof uid === "string" && API_UID.test(uid) && (!uids || uids.includes(uid))),
+      retentionDays: days,
+      maxSnapshots: (value) => Number.isInteger(value) && value >= 1 && value <= 1e3,
+      eventDays: days,
+      trashDays: days
+    };
+    var TYPOLOGIES2 = ["hero", "text", "media", "listing", "cards", "cta", "form", "layout"];
+    var TAG = /^[^<>\n]{1,24}$/;
+    var cleanTags = (value) => Array.isArray(value) ? [...new Set(value.filter((tag) => typeof tag === "string" && TAG.test(tag.trim())).map((tag) => tag.trim()))].slice(0, 10) : [];
+    var validTags = (value) => Array.isArray(value) && value.length <= 10 && value.every((tag) => typeof tag === "string" && TAG.test(tag.trim()));
+    var GUESSES = [
+      ["hero", /hero|banner|cover/],
+      ["text", /text|rich|quote|title/],
+      ["media", /image|media|video|gallery|carousel/],
+      ["listing", /list|query|archive|related|posts|projects/],
+      ["cards", /card/],
+      ["cta", /cta|button|link/],
+      ["form", /form|contact/],
+      ["layout", /wrapper|column|grid|divider|divisor|spacer|section/]
+    ];
+    function guessTypology(uid, displayName = "") {
+      const name = `${uid.split(".").pop()} ${displayName}`.toLowerCase();
+      return GUESSES.find(([, pattern]) => pattern.test(name))?.[0] || "text";
+    }
+    function facetsOf(uid, schema, schemas = {}) {
+      const facets = /* @__PURE__ */ new Set();
+      const read = (attributes, nested) => {
+        for (const attr of Object.values(attributes || {})) {
+          if (attr?.type === "media") {
+            const allowed = attr.allowedTypes;
+            if (!allowed || allowed.includes("images")) facets.add("image");
+            if (!allowed || allowed.includes("videos")) facets.add("video");
+            if (attr.multiple) facets.add("gallery");
+          } else if (["richtext", "blocks"].includes(attr?.type) || attr?.type === "customField" && /ckeditor/i.test(String(attr.customField))) facets.add("richtext");
+          else if (attr?.type === "relation") facets.add("dynamic");
+          else if (attr?.type === "component") {
+            if (attr.repeatable) facets.add("list");
+            if (!nested) read(schemas[attr.component]?.attributes, true);
+          }
+        }
+      };
+      read(schema?.attributes, false);
+      if (/query|archive|related/i.test(uid)) facets.add("dynamic");
+      if (/form|contact/i.test(`${uid} ${schema?.info?.displayName || ""}`)) facets.add("form");
+      return [...facets];
+    }
     var safeUrl2 = (value) => typeof value === "string" && (/^\/(?!\/)/.test(value) || /^https?:\/\//.test(value)) ? value : void 0;
-    var { safeGroups: safeGroups2 } = require_groups();
+    var { safeGroups: safeGroups2, validLayout } = require_groups();
     var safeVersion = (value) => typeof value === "string" && /^[\w.-]{1,32}$/.test(value) ? value : void 0;
     var fail2 = (message, details) => {
       let ValidationError;
@@ -156,6 +301,16 @@ var require_settings = __commonJS({
           ["label", "description", "category", "keywords"].filter((key) => typeof entry[key] === "string").map((key) => [key, entry[key]])
         );
         entries[uid].image = safeUrl2(entry.image);
+        if (TYPOLOGIES2.includes(entry.typology)) entries[uid].typology = entry.typology;
+        const tags = cleanTags(entry.tags);
+        if (tags.length || entries[uid].category) entries[uid].tags = tags.length ? tags : cleanTags([entries[uid].category]);
+      }
+      for (const [uid, schema] of Object.entries(config.schemas || {})) {
+        const entry = entries[uid] ||= {};
+        for (const [key, value] of Object.entries(config.blocks?.[uid] || {})) if (entry[key] === void 0) entry[key] = value;
+        entry.facets = facetsOf(uid, schema, config.schemas);
+        entry.typology ||= guessTypology(uid, schema?.info?.displayName);
+        entry.tags ||= [];
       }
       return {
         components: entries,
@@ -167,7 +322,8 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2) {
+    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = null) {
+      const types = typeMap(contentTypeUids2);
       if (!input || typeof input !== "object" || Array.isArray(input)) fail2("Settings must be an object");
       if (JSON.stringify(input).length > 64 * 1024) fail2("Settings payload too large");
       const out = structuredClone(DEFAULTS2);
@@ -179,9 +335,9 @@ var require_settings = __commonJS({
       }
       for (const [key, value] of Object.entries(input.editor || {})) {
         if (!(key in DEFAULTS2.editor)) fail2(`Unknown editor option "${key}"`);
-        const valid = key === "initialState" ? INITIAL_STATES.includes(value) : key === "previewMode" ? PREVIEW_MODES.includes(value) : key === "previewUrl" ? value === "" || typeof value === "string" && PREVIEW_URL.test(value) : typeof value === "boolean";
+        const valid = key === "initialState" ? INITIAL_STATES.includes(value) : key === "previewMode" ? PREVIEW_MODES.includes(value) : key === "hiddenBlocks" ? HIDDEN_MODES.includes(value) : key === "previewUrl" ? value === "" || typeof value === "string" && PREVIEW_URL.test(value) : key === "blockPreviewUrl" ? blockPreviewUrl(value) : key === "lazyFields" ? lazyFields(value) : key === "previewToolbar" ? previewToolbar(value) : key === "previewDevices" ? previewDevices(value) : typeof value === "boolean";
         if (!valid) fail2(`Invalid value for editor option "${key}"`);
-        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : value;
+        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : key === "lazyFields" ? [...new Set(value)] : key === "previewDevices" ? cleanDevices(value) : value;
       }
       const components = input.components || {};
       if (typeof components !== "object" || Array.isArray(components)) fail2("components must be an object");
@@ -193,16 +349,45 @@ var require_settings = __commonJS({
           if (key === "template") {
             if (!TEMPLATES2.includes(entry.template)) fail2(`Unknown template for "${uid}"`);
             clean.template = entry.template;
+          } else if (key === "typology") {
+            if (!TYPOLOGIES2.includes(entry.typology)) fail2(`Unknown typology for "${uid}"`);
+            clean.typology = entry.typology;
+          } else if (key === "tags") {
+            if (!validTags(entry.tags)) fail2(`Invalid tags for "${uid}": up to 10, each 1 to 24 characters`);
+            clean.tags = cleanTags(entry.tags);
           } else if (key === "mediaId") {
             if (!Number.isInteger(entry.mediaId) || entry.mediaId <= 0) fail2(`Invalid media for "${uid}"`);
             clean.mediaId = entry.mediaId;
+          } else if (key === "layout") {
+            if (!validLayout(entry.layout, schemas && (schemas[uid]?.attributes || {}))) fail2(`Invalid layout for "${uid}": columnsField (and mobileColumnsField) must name a number, string or numeric enumeration attribute of the component; maxColumns 1 to 12`);
+            clean.layout = structuredClone(entry.layout);
           } else fail2(`Unknown component setting "${key}"`);
         }
         if (Object.keys(clean).length) out.components[uid] = clean;
       }
+      const perType = input.contentTypes || {};
+      if (typeof perType !== "object" || Array.isArray(perType)) fail2("contentTypes must be an object");
+      for (const [uid, entry] of Object.entries(perType)) {
+        if (!(uid in types)) fail2(`Unknown content type "${uid}"`);
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) fail2(`Invalid entry for "${uid}"`);
+        for (const [key, value] of Object.entries(entry)) {
+          if (!(key in TYPE_KEYS)) fail2(`Unknown content type setting "${key}"`);
+          if (!TYPE_KEYS[key](value, types[uid])) fail2(`Invalid value for "${key}" of "${uid}"`);
+        }
+        if (Object.keys(entry).length) out.contentTypes[uid] = { ...structuredClone(entry), ...entry.previewDevices && { previewDevices: cleanDevices(entry.previewDevices) } };
+      }
+      const history = input.history || {};
+      if (typeof history !== "object" || Array.isArray(history)) fail2("history must be an object");
+      for (const [key, value] of Object.entries(history)) {
+        if (!(key in HISTORY_KEYS)) fail2(`Unknown history option "${key}"`);
+        if (!HISTORY_KEYS[key](value, historyTypes)) fail2(`Invalid value for history option "${key}"`);
+        out.history[key] = Array.isArray(value) ? [...new Set(value)] : value;
+      }
+      if (out.history.eventDays < out.history.retentionDays) fail2("history.eventDays must be at least history.retentionDays");
       return out;
     }
-    function mergeSaved2(saved, componentUids2) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = null) {
+      const types = typeMap(contentTypeUids2);
       const out = structuredClone(DEFAULTS2);
       if (!saved || typeof saved !== "object") return out;
       for (const key of Object.keys(DEFAULTS2.palette)) if (COLOR.test(String(saved.palette?.[key]))) out.palette[key] = saved.palette[key];
@@ -211,19 +396,1307 @@ var require_settings = __commonJS({
         if (value === void 0 || typeof value !== typeof DEFAULTS2.editor[key]) continue;
         if (key === "initialState" && !INITIAL_STATES.includes(value)) continue;
         if (key === "previewMode" && !PREVIEW_MODES.includes(value)) continue;
+        if (key === "hiddenBlocks" && !HIDDEN_MODES.includes(value)) continue;
         if (key === "previewUrl" && value && !PREVIEW_URL.test(value)) continue;
+        if (key === "blockPreviewUrl" && !blockPreviewUrl(value)) continue;
+        if (key === "previewToolbar" && !previewToolbar(value)) continue;
+        if (key === "previewDevices" && !previewDevices(value)) continue;
+        if (key === "lazyFields") {
+          if (!Array.isArray(value)) continue;
+          out.editor[key] = [...new Set(value.filter((uid) => lazyFields([uid])))].slice(0, 20);
+          continue;
+        }
         out.editor[key] = value;
       }
-      for (const [uid, entry] of Object.entries(saved.components || {})) if (componentUids2.includes(uid) && entry && typeof entry === "object") out.components[uid] = { ...entry };
+      for (const [uid, entry] of Object.entries(saved.components || {})) {
+        if (!componentUids2.includes(uid) || !entry || typeof entry !== "object") continue;
+        const clean = { ...entry };
+        if ("typology" in clean && !TYPOLOGIES2.includes(clean.typology)) delete clean.typology;
+        if ("tags" in clean) {
+          clean.tags = cleanTags(clean.tags);
+          if (!clean.tags.length) delete clean.tags;
+        }
+        if ("layout" in clean && !validLayout(clean.layout, schemas && (schemas[uid]?.attributes || {}))) delete clean.layout;
+        if (Object.keys(clean).length) out.components[uid] = clean;
+      }
+      for (const [uid, entry] of Object.entries(saved.contentTypes || {})) {
+        if (!(uid in types) || !entry || typeof entry !== "object") continue;
+        const fix = (key, value) => key === "sidebar" && Array.isArray(value) ? value.filter((item) => sidebarItem(item, types[uid])) : value;
+        const clean = Object.fromEntries(Object.entries(entry).map(([key, value]) => [key, fix(key, value)]).filter(([key, value]) => TYPE_KEYS[key]?.(value, types[uid])));
+        if (Object.keys(clean).length) out.contentTypes[uid] = clean;
+      }
+      for (const key of Object.keys(HISTORY_KEYS)) {
+        let value = saved.history?.[key];
+        if (key === "contentTypes" && Array.isArray(value)) value = value.filter((uid) => HISTORY_KEYS.contentTypes([uid], historyTypes));
+        if (value !== void 0 && HISTORY_KEYS[key](value, historyTypes)) out.history[key] = value;
+      }
+      out.history.eventDays = Math.max(out.history.eventDays, out.history.retentionDays);
+      return out;
+    }
+    var ENTRY_KEYS = ["components", "contentTypes"];
+    var UNSET_WHEN_EMPTY = ["previewUrl", "blockPreviewUrl"];
+    var withoutEmpty = (editor) => Object.fromEntries(Object.entries(editor).filter(([key, value]) => !(UNSET_WHEN_EMPTY.includes(key) && value === "")));
+    function layer2(base, saved) {
+      if (!base) return saved;
+      const doc = saved && typeof saved === "object" ? saved : {};
+      const own = (key) => doc[key] && typeof doc[key] === "object" ? key === "editor" ? withoutEmpty(doc[key]) : doc[key] : {};
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => [key, { ...base[key], ...own(key) }]));
+    }
+    function overrides2(next, base) {
+      if (!base) return next;
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => {
+        const entries = Object.entries(next[key] || {}).filter(([name, value]) => JSON.stringify(value) !== JSON.stringify(base[key]?.[name]) && !(key === "editor" && UNSET_WHEN_EMPTY.includes(name) && value === ""));
+        if (ENTRY_KEYS.includes(key)) {
+          for (const uid of Object.keys(base[key] || {})) if (!(uid in (next[key] || {}))) entries.push([uid, {}]);
+        }
+        return [key, Object.fromEntries(entries)];
+      }));
+    }
+    var FIELD_TEXT = { label: 80, description: 300, placeholder: 120, help: 500 };
+    var LOCALE = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+    var plain = (value) => value && typeof value === "object" && !Array.isArray(value);
+    var fieldText = (value, max) => typeof value === "string" ? value.trim() !== "" && value.length <= max : plain(value) && Object.keys(value).length > 0 && Object.keys(value).length <= 30 && Object.entries(value).every(([locale, text2]) => LOCALE.test(locale) && fieldText(text2, max));
+    function validateFields2(input, schemas = {}, stale = []) {
+      if (input === null || input === void 0) return {};
+      if (!plain(input)) fail2("fields must be an object");
+      if (JSON.stringify(input).length > 256 * 1024) fail2("fields config too large");
+      const out = {};
+      for (const [uid, entries] of Object.entries(input)) {
+        if (!plain(entries)) fail2(`Invalid entry for "${uid}"`);
+        for (const [name, entry] of Object.entries(entries)) {
+          if (!plain(entry)) fail2(`Invalid entry for "${uid}.${name}"`);
+          for (const [key, value] of Object.entries(entry)) {
+            if (!(key in FIELD_TEXT)) fail2(`Unknown field setting "${key}" of "${uid}.${name}"`);
+            if (!fieldText(value, FIELD_TEXT[key])) fail2(`Invalid ${key} of "${uid}.${name}": a string of 1 to ${FIELD_TEXT[key]} characters, or { "<locale>": string }`);
+          }
+          if (!schemas[uid]?.includes(name)) {
+            stale.push(`${uid}.${name}`);
+            continue;
+          }
+          ;
+          (out[uid] ||= {})[name] = structuredClone(entry);
+        }
+      }
       return out;
     }
-    module2.exports = { PLUGIN: PLUGIN2, TEMPLATES: TEMPLATES2, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, mergeSaved: mergeSaved2, safeUrl: safeUrl2, fail: fail2 };
+    var str = (max) => (value) => typeof value === "string" && value.trim() !== "" && value.length <= max;
+    var BLOCK_META = { label: str(80), typology: (value) => TYPOLOGIES2.includes(value), tags: validTags, keywords: str(500), image: (value) => safeUrl2(value) !== void 0 };
+    var localize = (holder, key, source, locale, text2) => {
+      holder[key] = { ...plain(holder[key]) ? holder[key] : { en: holder[key] ?? source }, [locale]: text2 };
+    };
+    function schemaMetadata2(schemas = {}, translations = null, notes = []) {
+      const blocks = {}, fields = {};
+      const own = (holder, where) => {
+        const value = holder?.pluginOptions?.blockscene;
+        if (value === void 0 || plain(value)) return value || {};
+        notes.push(`${where}: pluginOptions.blockscene must be an object`);
+        return {};
+      };
+      for (const [uid, schema] of Object.entries(schemas)) {
+        if (!uid.includes("::")) {
+          const block = {};
+          for (const [key, value] of Object.entries(own(schema, uid))) {
+            if (!Object.hasOwn(BLOCK_META, key)) notes.push(`${uid}: unknown key "${key}"`);
+            else if (!BLOCK_META[key](value)) notes.push(`${uid}: invalid ${key}`);
+            else block[key] = key === "tags" ? cleanTags(value) : value;
+          }
+          if (typeof schema?.info?.description === "string" && schema.info.description.trim()) block.description = schema.info.description;
+          if (Object.keys(block).length) blocks[uid] = block;
+        }
+        for (const [name, attr] of Object.entries(schema?.attributes || {})) {
+          const texts = {};
+          for (const [key, value] of Object.entries(own(attr, `${uid}.${name}`))) {
+            if (!Object.hasOwn(FIELD_TEXT, key)) notes.push(`${uid}.${name}: unknown key "${key}"`);
+            else if (!str(FIELD_TEXT[key])(value)) notes.push(`${uid}.${name}: ${key} must be a string of 1 to ${FIELD_TEXT[key]} characters`);
+            else texts[key] = value;
+          }
+          if (Object.keys(texts).length) (fields[uid] ||= {})[name] = texts;
+        }
+      }
+      if (translations != null && !plain(translations)) {
+        notes.push('translations must be { "<locale>": { "<key>": text } }');
+        translations = null;
+      }
+      const stale = [];
+      for (const [locale, entries] of Object.entries(translations || {})) {
+        if (!LOCALE.test(locale) || !plain(entries) || JSON.stringify(entries).length > 256 * 1024) {
+          notes.push(`translations "${locale}" ignored: expected a locale code with a flat { "<key>": text } map under 256 KB`);
+          continue;
+        }
+        for (const [key, text2] of Object.entries(entries)) {
+          const uid = Object.keys(schemas).find((uid2) => key === uid2 || key.startsWith(`${uid2}.`));
+          const [name, part = "label", extra] = uid ? key.slice(uid.length + 1).split(".") : [];
+          const block = uid && !uid.includes("::");
+          const target = block && key === uid ? [blocks[uid] ||= {}, "label", schemas[uid]?.info?.displayName || uid, 80] : block && key === `${uid}.description` ? [blocks[uid] ||= {}, "description", null, 300] : uid && Object.hasOwn(schemas[uid]?.attributes || {}, name) && Object.hasOwn(FIELD_TEXT, part) && extra === void 0 ? [null, part, null, FIELD_TEXT[part]] : null;
+          if (!target) {
+            stale.push(`${locale} "${key}"`);
+            continue;
+          }
+          const [holder, field, source, max] = target;
+          if (!str(max)(text2)) {
+            notes.push(`translations ${locale} "${key}": a string of 1 to ${max} characters`);
+            continue;
+          }
+          localize(holder || ((fields[uid] ||= {})[name] ||= {}), field, source, locale, text2);
+        }
+      }
+      if (stale.length) notes.push(`translation keys naming no block or field were skipped: ${stale.slice(0, 20).join(", ")}${stale.length > 20 ? ` and ${stale.length - 20} more` : ""}`);
+      return { blocks, fields };
+    }
+    var VARIANT = { id: /^[a-z0-9][a-z0-9_-]{0,39}$/, perComponent: 12, bytes: 16 * 1024, total: 256 * 1024, items: 100 };
+    var text = (value) => typeof value === "string";
+    var finite = (value) => typeof value === "number" && Number.isFinite(value);
+    var SCALARS = {
+      string: text,
+      text,
+      richtext: text,
+      email: text,
+      uid: text,
+      date: text,
+      datetime: text,
+      time: text,
+      timestamp: text,
+      integer: Number.isInteger,
+      biginteger: (value) => Number.isInteger(value) || text(value) && /^-?\d{1,19}$/.test(value),
+      float: finite,
+      decimal: finite,
+      boolean: (value) => typeof value === "boolean",
+      json: () => true,
+      customField: () => true,
+      blocks: Array.isArray,
+      enumeration: (value, attr) => (attr.enum || []).includes(value)
+    };
+    function variantValues(values, schema, schemas, path, skipped) {
+      if (!plain(values)) throw new Error(`${path} must be an object`);
+      const out = {};
+      for (const [name, value] of Object.entries(values)) {
+        if (name === "id" || name === "__component") continue;
+        const attr = schema.attributes?.[name], at = `${path}.${name}`;
+        if (!attr) throw new Error(`${at} is not an attribute of the component`);
+        if (attr.type === "media" || attr.type === "relation") {
+          skipped.push(at);
+          continue;
+        }
+        if (attr.type === "component") {
+          const nested = schemas[attr.component], max = Math.min(attr.max ?? Infinity, VARIANT.items);
+          if (!nested) throw new Error(`${at}: unknown component "${attr.component}"`);
+          if (!attr.repeatable) out[name] = value === null ? null : variantValues(value, nested, schemas, at, skipped);
+          else if (!Array.isArray(value) || value.length > max) throw new Error(`${at} must be a list of at most ${max} items`);
+          else out[name] = value.map((item, index) => variantValues(item, nested, schemas, `${at}[${index}]`, skipped));
+        } else if (value === null || SCALARS[attr.type]?.(value, attr)) out[name] = structuredClone(value);
+        else throw new Error(`${at}: ${SCALARS[attr.type] ? `not a valid ${attr.type}` : `${attr.type} values are not supported`}`);
+      }
+      return out;
+    }
+    function validateVariants2(config, schemas = {}, notes = []) {
+      const out = {};
+      let total = 0;
+      for (const [uid, entry] of Object.entries(plain(config) ? config : {})) {
+        if (!plain(entry) || entry.variants === void 0) continue;
+        if (!schemas[uid]) {
+          notes.push(`${uid}: unknown component`);
+          continue;
+        }
+        if (!Array.isArray(entry.variants) || entry.variants.length > VARIANT.perComponent) {
+          notes.push(`${uid}: variants must be a list of at most ${VARIANT.perComponent}`);
+          continue;
+        }
+        const ids = /* @__PURE__ */ new Set();
+        entry.variants.forEach((variant, index) => {
+          const name = `${uid} variant "${variant?.id ?? index}"`;
+          try {
+            if (!plain(variant) || Object.keys(variant).some((key) => !["id", "label", "values"].includes(key))) throw new Error("expected { id, label, values }");
+            if (!text(variant.id) || !VARIANT.id.test(variant.id) || ids.has(variant.id)) throw new Error('id must be 1 to 40 lowercase letters, digits, "-" or "_", unique per component');
+            if (!fieldText(variant.label, 60)) throw new Error('label must be a string of 1 to 60 characters, or { "<locale>": string }');
+            const skipped = [];
+            const values = variantValues(variant.values ?? {}, schemas[uid], schemas, "values", skipped);
+            const size = JSON.stringify(values).length;
+            if (size > VARIANT.bytes) throw new Error(`values over ${VARIANT.bytes / 1024} KB`);
+            if (total + size > VARIANT.total) throw new Error(`all variants together over ${VARIANT.total / 1024} KB`);
+            if (skipped.length) notes.push(`${name}: media and relation values are not inserted (${skipped.slice(0, 5).join(", ")}${skipped.length > 5 ? ", ..." : ""})`);
+            ids.add(variant.id);
+            total += size;
+            (out[uid] ||= []).push({ id: variant.id, label: structuredClone(variant.label), values });
+          } catch (error) {
+            notes.push(`${name} ignored: ${error.message}`);
+          }
+        });
+      }
+      return out;
+    }
+    var PREFS = { starred: 200, recent: 20 };
+    function validatePrefs2(input, componentUids2) {
+      if (!input || typeof input !== "object" || Array.isArray(input)) fail2("Preferences must be an object");
+      const out = { starred: [], recent: [] };
+      for (const [key, value] of Object.entries(input)) {
+        if (!(key in PREFS)) fail2(`Unknown preference "${key}"`);
+        if (!Array.isArray(value) || value.length > PREFS[key] || !value.every((uid) => typeof uid === "string" && componentUids2.includes(uid))) fail2(`Invalid value for "${key}"`);
+        out[key] = [...new Set(value)];
+      }
+      return out;
+    }
+    var mergePrefs2 = (saved, componentUids2) => Object.fromEntries(Object.entries(PREFS).map(([key, max]) => [key, Array.isArray(saved?.[key]) ? [...new Set(saved[key].filter((uid) => componentUids2.includes(uid)))].slice(0, max) : []]));
+    module2.exports = { PLUGIN: PLUGIN2, HIDDEN_MODES, TEMPLATES: TEMPLATES2, TYPOLOGIES: TYPOLOGIES2, guessTypology, facetsOf, validatePrefs: validatePrefs2, mergePrefs: mergePrefs2, ICONS, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, validateFields: validateFields2, validateVariants: validateVariants2, schemaMetadata: schemaMetadata2, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
+  }
+});
+
+// server/hidden.js
+var require_hidden = __commonJS({
+  "server/hidden.js"(exports2, module2) {
+    "use strict";
+    var NAME = /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/;
+    var DEFAULT_NAME = "bsHidden";
+    var hiddenName2 = (value) => value === void 0 ? DEFAULT_NAME : value === false ? false : typeof value === "string" && NAME.test(value) ? value : null;
+    var zoneComponents = (contentTypes) => [...new Set(Object.values(contentTypes || {}).flatMap((schema) => Object.values(schema?.attributes || {}).filter((attr) => attr?.type === "dynamiczone").flatMap((attr) => attr.components || [])))];
+    function injectHidden2(components, contentTypes, name) {
+      const added = [], skipped = [];
+      for (const uid of zoneComponents(contentTypes)) {
+        const schema = components?.[uid];
+        if (!schema) continue;
+        schema.attributes ||= {};
+        const current = schema.attributes[name];
+        if (current && current.type !== "boolean") {
+          skipped.push(uid);
+          continue;
+        }
+        if (!current) schema.attributes[name] = { type: "boolean", default: false, configurable: false };
+        added.push(uid);
+      }
+      return { added, skipped };
+    }
+    function hideFromBuilder2(services, uids, name) {
+      const has = new Set(uids);
+      const drop = (attributes) => Array.isArray(attributes) ? attributes.filter((attr) => attr?.name !== name) : attributes && typeof attributes === "object" ? Object.fromEntries(Object.entries(attributes).filter(([key]) => key !== name)) : attributes;
+      const extend = (uid, wrap) => {
+        if (services?.get?.(uid)) services.extend(uid, wrap);
+      };
+      extend("plugin::content-type-builder.components", (service) => ({ ...service, formatComponent(component, ...rest) {
+        const out = service.formatComponent(component, ...rest);
+        return has.has(component?.uid) && out?.schema ? { ...out, schema: { ...out.schema, attributes: drop(out.schema.attributes) } } : out;
+      } }));
+      extend("plugin::content-type-builder.schema", (service) => ({ ...service, async getSchema(...args) {
+        const out = await service.getSchema(...args);
+        for (const uid of has) if (out?.components?.[uid]) out.components[uid] = { ...out.components[uid], attributes: drop(out.components[uid].attributes) };
+        return out;
+      } }));
+    }
+    function stripHidden(data, schema, schemaOf, name, depth = 0) {
+      if (!data || typeof data !== "object" || !schema || depth > 20) return data;
+      if (Array.isArray(data)) {
+        data.forEach((item) => stripHidden(item, schema, schemaOf, name, depth));
+        return data;
+      }
+      const walk = (value, target) => Array.isArray(value) ? value.forEach((item) => stripHidden(item, target, schemaOf, name, depth + 1)) : stripHidden(value, target, schemaOf, name, depth + 1);
+      for (const [key, attr] of Object.entries(schema.attributes || {})) {
+        const value = data[key];
+        if (value == null || typeof value !== "object") continue;
+        if (attr?.type === "dynamiczone" && Array.isArray(value)) {
+          data[key] = value.filter((row) => !(row && row[name] === true));
+          for (const row of data[key]) stripHidden(row, schemaOf(row?.__component), schemaOf, name, depth + 1);
+        } else if (attr?.type === "component") walk(value, schemaOf(attr.component));
+        else if (attr?.type === "relation" && attr.target) walk(value, schemaOf(attr.target));
+      }
+      return data;
+    }
+    var contentApi = (strapi) => {
+      try {
+        return strapi.requestContext?.get?.()?.state?.route?.info?.type === "content-api";
+      } catch {
+        return false;
+      }
+    };
+    var READS = ["findMany", "findOne", "findFirst"];
+    function registerHiddenStrip2(strapi, name, plugin) {
+      if (!name) return;
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const stripping = async () => {
+        try {
+          return (await plugin.service("settings").get()).editor.hiddenBlocks === "strip";
+        } catch {
+          return true;
+        }
+      };
+      const apply = async (uid, result) => result && contentApi(strapi) && await stripping() ? stripHidden(result, schemaOf(uid), schemaOf, name) : result;
+      if (strapi.documents?.use) {
+        strapi.documents.use(async (ctx, next) => {
+          const result = await next();
+          return READS.includes(ctx.action) ? apply(ctx.uid, result) : result;
+        });
+        return;
+      }
+      strapi.entityService?.decorate?.((service) => ({
+        async findMany(uid, params) {
+          return apply(uid, await service.findMany(uid, params));
+        },
+        async findOne(uid, id, params) {
+          return apply(uid, await service.findOne(uid, id, params));
+        },
+        async findPage(uid, params) {
+          const page = await service.findPage(uid, params);
+          if (page?.results) await apply(uid, page.results);
+          return page;
+        }
+      }));
+    }
+    module2.exports = { DEFAULT_NAME, hiddenName: hiddenName2, zoneComponents, injectHidden: injectHidden2, hideFromBuilder: hideFromBuilder2, stripHidden, registerHiddenStrip: registerHiddenStrip2 };
+  }
+});
+
+// server/diff.js
+var require_diff = __commonJS({
+  "server/diff.js"(exports2, module2) {
+    "use strict";
+    var IGNORED = ["id", "documentId", "locale", "localizations", "createdAt", "updatedAt", "publishedAt", "firstPublishedAt", "createdBy", "updatedBy", "strapi_stage", "strapi_assignee", "__temp_key__", "__pivot"];
+    var morph = (attr) => String(attr?.relation || "").toLowerCase().includes("morph");
+    var kept = (name, attr) => attr && !IGNORED.includes(name) && attr.type !== "password" && !(attr.type === "relation" && (morph(attr) || attr.visible === false));
+    var empty = (value) => value === null || value === void 0 || value === "";
+    function snapshotPopulate(uid, schemaOf, stack = []) {
+      const schema = schemaOf(uid);
+      if (!schema || stack.includes(uid)) return {};
+      const scalars = (component) => Object.entries(schemaOf(component)?.attributes || {}).filter(([name, attr]) => kept(name, attr) && !["relation", "media", "component", "dynamiczone"].includes(attr.type)).map(([name]) => name);
+      const nested = (component) => ({ select: scalars(component).length ? scalars(component) : ["id"], populate: snapshotPopulate(component, schemaOf, [...stack, uid]) });
+      const out = {};
+      for (const [name, attr] of Object.entries(schema.attributes || {})) {
+        if (!kept(name, attr)) continue;
+        if (attr.type === "relation") out[name] = { select: ["documentId", "locale"] };
+        else if (attr.type === "media") out[name] = { select: ["id"] };
+        else if (attr.type === "component") out[name] = nested(attr.component);
+        else if (attr.type === "dynamiczone") out[name] = { on: Object.fromEntries((attr.components || []).map((component) => [component, nested(component)])) };
+      }
+      return out;
+    }
+    function canonical(data, schema, schemaOf, { relations = true } = {}, depth = 0) {
+      const out = {};
+      if (!data || typeof data !== "object" || depth > 20) return out;
+      const idOf = (file) => file && typeof file === "object" ? file.id : file;
+      const ref = (item) => item && typeof item === "object" && item.documentId ? { documentId: item.documentId, ...item.locale && { locale: item.locale } } : null;
+      for (const [name, attr] of Object.entries(schema?.attributes || {})) {
+        const value = data[name];
+        if (!kept(name, attr) || empty(value)) continue;
+        if (attr.type === "relation") {
+          if (!relations) continue;
+          const refs = (Array.isArray(value) ? value : [value]).map(ref).filter(Boolean);
+          if (refs.length) out[name] = Array.isArray(value) ? refs : refs[0];
+        } else if (attr.type === "media") {
+          const ids = (Array.isArray(value) ? value : [value]).map(idOf).filter((id) => !empty(id));
+          if (ids.length) out[name] = attr.multiple ? ids : ids[0];
+        } else if (attr.type === "component") {
+          const child = schemaOf(attr.component);
+          if (attr.repeatable) {
+            if (Array.isArray(value) && value.length) out[name] = value.map((item) => canonical(item, child, schemaOf, { relations }, depth + 1));
+          } else out[name] = canonical(value, child, schemaOf, { relations }, depth + 1);
+        } else if (attr.type === "dynamiczone") {
+          if (Array.isArray(value) && value.length) out[name] = value.filter((row) => row && typeof row.__component === "string").map((row) => ({ __component: row.__component, ...canonical(row, schemaOf(row.__component), schemaOf, { relations }, depth + 1) }));
+        } else out[name] = value;
+      }
+      return out;
+    }
+    var stable = (value) => JSON.stringify(value, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]])) : v);
+    var same = (a, b) => stable(a ?? null) === stable(b ?? null);
+    function diffRows(before = [], after = []) {
+      const a = before.map(stable), b = after.map(stable);
+      const n = a.length, m = b.length;
+      if (n * m > 25e4) return after.map((row, to) => ({ op: a[to] === b[to] ? "same" : "changed", from: to < n ? to : void 0, to, uid: row.__component }));
+      const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+      for (let i2 = n - 1; i2 >= 0; i2--) for (let j2 = m - 1; j2 >= 0; j2--) lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+      const out = [];
+      const gap = (fromRows2, toRows2) => {
+        const removed = [...fromRows2];
+        for (const to of toRows2) {
+          const k = removed.findIndex((from) => before[from].__component === after[to].__component);
+          if (k === -1) out.push({ op: "added", to, uid: after[to].__component });
+          else out.push({ op: "changed", from: removed.splice(k, 1)[0], to, uid: after[to].__component });
+        }
+        for (const from of removed) out.push({ op: "removed", from, uid: before[from].__component });
+      };
+      let i = 0, j = 0, fromRows = [], toRows = [];
+      while (i < n || j < m) {
+        if (i < n && j < m && a[i] === b[j]) {
+          gap(fromRows, toRows);
+          fromRows = [];
+          toRows = [];
+          out.push({ op: "same", from: i, to: j, uid: after[j].__component });
+          i++;
+          j++;
+        } else if (j < m && (i >= n || lcs[i][j + 1] >= lcs[i + 1][j])) toRows.push(j++);
+        else fromRows.push(i++);
+      }
+      gap(fromRows, toRows);
+      return out;
+    }
+    function summarize(before, after, schema) {
+      const zones = Object.entries(schema?.attributes || {}).filter(([, attr]) => attr?.type === "dynamiczone").map(([name]) => name);
+      const blocks = { added: 0, removed: 0, changed: 0 };
+      if (!before) return { initial: true, fields: [], blocks };
+      const names = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after || {})])];
+      const fields = names.filter((name) => !zones.includes(name) && !same(before[name], after?.[name])).sort();
+      for (const name of zones) for (const { op } of diffRows(before[name], after?.[name])) if (op !== "same") blocks[op]++;
+      return { fields, blocks };
+    }
+    module2.exports = { IGNORED, kept, snapshotPopulate, canonical, stable, same, diffRows, summarize };
+  }
+});
+
+// server/trash.js
+var require_trash = __commonJS({
+  "server/trash.js"(exports2, module2) {
+    "use strict";
+    var { AsyncLocalStorage } = require("node:async_hooks");
+    var { PLUGIN: PLUGIN2 } = require_settings();
+    var { kept, canonical, stable } = require_diff();
+    var history = () => require_history();
+    var TRASH_UID = `plugin::${PLUGIN2}.trash`;
+    var STATUSES = ["trashed", "restored"];
+    var DAY = 24 * 60 * 60 * 1e3;
+    var BATCH = 500;
+    var restoring = new AsyncLocalStorage();
+    var trashContentType2 = { schema: {
+      kind: "collectionType",
+      collectionName: "blockscene_trash",
+      info: { singularName: "trash", pluralName: "trashes", displayName: "Blockscene trash" },
+      options: { draftAndPublish: false },
+      pluginOptions: { "content-manager": { visible: false }, "content-type-builder": { visible: false }, i18n: { localized: false } },
+      attributes: {
+        contentType: { type: "string", required: true },
+        relatedDocumentId: { type: "string", required: true },
+        // The document's main field (Content Manager setting) at delete time, for the list and the search.
+        title: { type: "string" },
+        // The locales the delete removed ([null] for a type without i18n).
+        locales: { type: "json" },
+        // [{ locale, status: 'draft' | 'published' | null (no Draft & Publish), snapshot }]: canonical snapshots (server/diff.js).
+        entries: { type: "json" },
+        // Links other documents' and blocks' unidirectional relations had to the deleted rows (see `incomingRows`).
+        incoming: { type: "json" },
+        actor: { type: "string", required: true },
+        actorName: { type: "string" },
+        deletedAt: { type: "datetime", required: true },
+        // deletedAt + trash retention at delete time; the nightly purge deletes the row after it.
+        expiresAt: { type: "datetime", required: true },
+        status: { type: "enumeration", enum: STATUSES, required: true, default: "trashed" },
+        restoredAs: { type: "string" },
+        restoredAt: { type: "datetime" },
+        size: { type: "integer" }
+      },
+      indexes: [{ name: "blockscene_trash_list", columns: ["status", "content_type", "deleted_at"] }, { name: "blockscene_trash_expiry", columns: ["expires_at"] }]
+    } };
+    var expiresAt = (deletedAt, days) => new Date(new Date(deletedAt).getTime() + days * DAY);
+    var isObject = (value) => value && typeof value === "object" && !Array.isArray(value);
+    var blank = (value) => value === null || value === void 0 || value === "" || Array.isArray(value) && !value.length;
+    var toMany = (attr) => /ToMany$|^manyWay$/.test(String(attr?.relation || ""));
+    var toOne = (attr) => ["oneToOne", "manyToOne"].includes(attr?.relation);
+    var uniqueFields = (schema) => Object.entries(schema?.attributes || {}).filter(([name, attr]) => kept(name, attr) && (attr.unique === true || attr.type === "uid")).map(([name]) => name);
+    function chooseEntries(entries) {
+      const chosen = /* @__PURE__ */ new Map();
+      for (const entry of Array.isArray(entries) ? entries : []) {
+        const locale = entry?.locale ?? null, current = chosen.get(locale);
+        if (!current || current.status === "published" && entry.status !== "published") chosen.set(locale, entry);
+      }
+      return chosen;
+    }
+    function restorePayload(snapshot, schema, schemaOf, { media = /* @__PURE__ */ new Set(), relation = () => false } = {}) {
+      const report = { removed: [], media: 0, relations: 0, blocks: 0 };
+      const ref = (item) => ({ documentId: item.documentId, ...item.locale && { locale: item.locale } });
+      const build = (data, schema2, top, depth) => {
+        const out = {};
+        if (!isObject(data) || depth > 20) return out;
+        for (const [name, value] of Object.entries(data)) {
+          if (name === "__component") continue;
+          const attr = schema2?.attributes?.[name];
+          const drop = () => {
+            if (top) report.removed.push(name);
+          };
+          if (!kept(name, attr)) {
+            drop();
+            continue;
+          }
+          const list = Array.isArray(value) ? value : value == null ? [] : [value];
+          if (attr.type === "relation") {
+            const refs = list.filter((item) => isObject(item) && typeof item.documentId === "string");
+            const found = refs.filter((item) => relation(attr.target, item));
+            report.relations += refs.length - found.length;
+            out[name] = toMany(attr) ? found.map(ref) : found[0] ? ref(found[0]) : null;
+          } else if (attr.type === "media") {
+            const ids = list.filter(Number.isInteger), found = ids.filter((id) => media.has(id));
+            report.media += ids.length - found.length;
+            out[name] = attr.multiple ? found : found[0] ?? null;
+          } else if (attr.type === "component") {
+            const child = schemaOf(attr.component);
+            if (!child) {
+              drop();
+              continue;
+            }
+            out[name] = attr.repeatable ? list.filter(isObject).map((item) => build(item, child, false, depth + 1)) : isObject(value) ? build(value, child, false, depth + 1) : null;
+          } else if (attr.type === "dynamiczone") {
+            const rows = list.filter((row) => isObject(row) && typeof row.__component === "string");
+            const allowed = rows.filter((row) => (attr.components || []).includes(row.__component) && schemaOf(row.__component));
+            report.blocks += rows.length - allowed.length;
+            out[name] = allowed.map((row) => ({ __component: row.__component, ...build(row, schemaOf(row.__component), false, depth + 1) }));
+          } else if (attr.type === "enumeration" && !(attr.enum || []).includes(value)) drop();
+          else out[name] = value;
+        }
+        return out;
+      };
+      return { data: build(snapshot, schema, true, 0), report };
+    }
+    function planRestore(entries, { schema, schemaOf, locales = null, defaultLocale = null, existing = null, singleTaken = false, taken = () => false, media, relation }) {
+      const blocking = [], warnings = [], steps = [];
+      const published = (Array.isArray(entries) ? entries : []).filter((entry) => entry?.status === "published").map((entry) => entry.locale ?? null);
+      if (published.length) warnings.push({ code: "published", locales: published });
+      if (singleTaken && !existing) blocking.push({ code: "singleExists" });
+      for (const [locale, entry] of chooseEntries(entries)) {
+        if (locales && !locales.includes(locale)) {
+          warnings.push({ code: "localeRemoved", locale });
+          continue;
+        }
+        if (existing?.includes(locale)) {
+          blocking.push({ code: "localeExists", locale });
+          continue;
+        }
+        const { data, report } = restorePayload(entry.snapshot, schema, schemaOf, { media, relation });
+        for (const field of uniqueFields(schema)) if (!blank(data[field]) && taken(field, locale, data[field])) blocking.push({ code: "unique", locale, field, value: String(data[field]).slice(0, 100) });
+        const required = Object.entries(schema?.attributes || {}).filter(([name, attr]) => attr?.required && kept(name, attr) && blank(data[name])).map(([name]) => name);
+        if (required.length) warnings.push({ code: "required", locale, fields: required });
+        if (report.removed.length) warnings.push({ code: "fieldsRemoved", locale, fields: report.removed });
+        for (const code of ["media", "relations", "blocks"]) if (report[code]) warnings.push({ code, locale, count: report[code] });
+        steps.push({ locale, data });
+      }
+      if (!steps.length && !blocking.length) blocking.push({ code: "nothing" });
+      steps.sort((a, b) => (b.locale === defaultLocale) - (a.locale === defaultLocale));
+      return { blocking, warnings, steps };
+    }
+    var incomingSources = (uid, models) => models.flatMap((model) => Object.entries(model.attributes || {}).filter(([, attr]) => attr?.type === "relation" && attr.target === uid && !attr.inversedBy && !attr.mappedBy && attr.joinTable).map(([field, attr]) => ({ owner: model.uid, kind: model.kind, field, joinTable: attr.joinTable, single: toOne(attr) })));
+    function incomingRows(source, links, deleted, owners = /* @__PURE__ */ new Map()) {
+      const { joinColumn, inverseJoinColumn, orderColumnName } = source.joinTable;
+      return links.filter((link) => deleted.has(link[inverseJoinColumn.name]) && !(source.kind === "contentType" && source.owner === source.target && deleted.has(link[joinColumn.name]))).map((link) => {
+        const target = deleted.get(link[inverseJoinColumn.name]), owner = owners.get(link[joinColumn.name]);
+        return {
+          owner: source.owner,
+          kind: source.kind,
+          field: source.field,
+          ownerId: link[joinColumn.name],
+          ...source.kind === "contentType" && { ownerDocumentId: owner?.documentId ?? null, ownerLocale: owner?.locale ?? null },
+          locale: target.locale ?? null,
+          published: Boolean(target.published),
+          order: orderColumnName ? link[orderColumnName] ?? null : null
+        };
+      });
+    }
+    function previewOf(snapshot, schema, schemaOf) {
+      const fields = [], blocks = [];
+      const text = (value) => {
+        const s = typeof value === "string" ? value : stable(value);
+        return s.length > 200 ? `${s.slice(0, 199)}\u2026` : s;
+      };
+      for (const [name, value] of Object.entries(isObject(snapshot) ? snapshot : {})) {
+        const attr = schema?.attributes?.[name];
+        if (attr?.type === "dynamiczone") {
+          for (const row of Array.isArray(value) ? value : []) blocks.push({ zone: name, uid: row?.__component, name: schemaOf(row?.__component)?.info?.displayName || row?.__component });
+          continue;
+        }
+        const count = Array.isArray(value) ? value.length : 1;
+        fields.push({ name, type: attr?.type || "removed", ...["relation", "media", "component"].includes(attr?.type) ? { count } : { value: text(value) } });
+      }
+      return { fields, blocks };
+    }
+    function trashService2({ strapi }) {
+      const events = () => strapi.plugin(PLUGIN2).service("history");
+      const rows = () => strapi.db.query(TRASH_UID);
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const localized = (uid) => Boolean(schemaOf(uid)?.pluginOptions?.i18n?.localized);
+      const draftAndPublish = (uid) => schemaOf(uid)?.options?.draftAndPublish === true;
+      const models = () => [...Object.values(strapi.contentTypes || {}).map((model) => ({ uid: model.uid, kind: "contentType" })), ...Object.values(strapi.components || {}).map((model) => ({ uid: model.uid, kind: "component" }))].map((model) => ({ ...model, attributes: strapi.db.metadata.get(model.uid)?.attributes })).filter((model) => model.attributes);
+      const table = (trx, name) => strapi.db.getConnection(name).transacting(trx);
+      const lookups = async (uid, snapshots) => {
+        const ids = /* @__PURE__ */ new Set(), refs = [];
+        for (const snapshot of snapshots) {
+          const found = history().refsOf(snapshot, schemaOf(uid), schemaOf);
+          found.media.forEach((id) => ids.add(id));
+          refs.push(...found.relations);
+        }
+        const files = ids.size ? await strapi.db.query("plugin::upload.file").findMany({ select: ["id"], where: { id: { $in: [...ids] } } }) : [];
+        const present = /* @__PURE__ */ new Set();
+        for (const target of [...new Set(refs.map((ref) => ref.target))]) {
+          if (!strapi.contentTypes?.[target]) continue;
+          const found = await strapi.db.query(target).findMany({ select: ["documentId", "locale"], where: {
+            documentId: { $in: [...new Set(refs.filter((ref) => ref.target === target).map((ref) => ref.documentId))] },
+            ...draftAndPublish(target) && { publishedAt: { $null: true } }
+          } });
+          for (const row of found) {
+            present.add(`${target}|${row.documentId}|${row.locale || ""}`);
+            present.add(`${target}|${row.documentId}|*`);
+          }
+        }
+        return { media: new Set(files.map((file) => file.id)), relation: (target, ref) => present.has(`${target}|${ref.documentId}|${localized(target) && ref.locale ? ref.locale : "*"}`) };
+      };
+      const resolveIncoming = async (uid, incoming, locales, trx) => {
+        const out = { links: [], gone: 0, published: 0, replaced: 0 };
+        for (const link of Array.isArray(incoming) ? incoming : []) {
+          if (!locales.includes(link.locale)) continue;
+          if (link.published) {
+            out.published++;
+            continue;
+          }
+          const attr = strapi.db.metadata.get(link.owner)?.attributes?.[link.field];
+          if (!attr?.joinTable || attr.target !== uid) {
+            out.gone++;
+            continue;
+          }
+          let ownerId = null;
+          if (link.kind === "component") ownerId = (await strapi.db.query(link.owner).findOne({ select: ["id"], where: { id: link.ownerId } }))?.id ?? null;
+          else if (strapi.contentTypes?.[link.owner] && link.ownerDocumentId) ownerId = (await strapi.db.query(link.owner).findOne({ select: ["id"], where: {
+            documentId: link.ownerDocumentId,
+            ...localized(link.owner) && { locale: link.ownerLocale },
+            ...draftAndPublish(link.owner) && { publishedAt: { $null: true } }
+          } }))?.id ?? null;
+          if (!ownerId) {
+            out.gone++;
+            continue;
+          }
+          const { joinTable } = attr;
+          if (toOne(attr) && await table(trx, joinTable.name).where(joinTable.joinColumn.name, ownerId).first()) {
+            out.replaced++;
+            continue;
+          }
+          out.links.push({ ...link, ownerRowId: ownerId, joinTable });
+        }
+        return out;
+      };
+      const self = {
+        TRASH_UID,
+        // Before the delete, in its transaction: the links other documents and blocks have to the rows about to be deleted.
+        async incoming(uid, deleted) {
+          if (!deleted.size) return [];
+          return strapi.db.transaction(async ({ trx }) => {
+            const out = [];
+            for (const source of incomingSources(uid, models())) {
+              const links = await table(trx, source.joinTable.name).select("*").whereIn(source.joinTable.inverseJoinColumn.name, [...deleted.keys()]);
+              if (!links.length) continue;
+              const owners = source.kind === "contentType" && strapi.contentTypes?.[source.owner] ? new Map((await strapi.db.query(source.owner).findMany({
+                select: ["id", "documentId", "locale"],
+                where: { id: { $in: [...new Set(links.map((link) => link[source.joinTable.joinColumn.name]))] } }
+              })).map((row) => [row.id, row])) : /* @__PURE__ */ new Map();
+              out.push(...incomingRows({ ...source, target: uid }, links, deleted, owners));
+            }
+            return out;
+          });
+        },
+        // After the delete, in its transaction: the trash row. drafts/published: the stored rows read before the delete.
+        async record({ uid, documentId, locales, drafts, published, incoming, actor, days }) {
+          const dp = draftAndPublish(uid);
+          const entries = [...drafts.map((row) => [row, dp ? "draft" : null]), ...published.map((row) => [row, "published"])].map(([row, status]) => ({ locale: row.locale ?? null, status, snapshot: canonical(row, schemaOf(uid), schemaOf) }));
+          const main = await events().mainField(uid);
+          const first = chooseEntries(entries);
+          const source = first.get(await events().scope(uid).then((list) => list?.[0] ?? null).catch(() => null)) || [...first.values()][0];
+          const title = main && source?.snapshot?.[main] != null ? String(source.snapshot[main]).slice(0, 255) : null;
+          const deletedAt = /* @__PURE__ */ new Date();
+          return rows().create({ data: {
+            contentType: uid,
+            relatedDocumentId: documentId,
+            title,
+            locales: locales || [...new Set(entries.map((entry) => entry.locale))],
+            entries,
+            incoming,
+            ...actor,
+            deletedAt,
+            expiresAt: expiresAt(deletedAt, days),
+            status: "trashed",
+            size: Buffer.byteLength(stable({ entries, incoming }))
+          } });
+        },
+        // One page of trash rows, without their snapshots. `types`: the content types the user may read.
+        async list({ contentType, status = "trashed", page = 1, pageSize = 20, types }) {
+          const where = { status, contentType: contentType ? contentType : { $in: types } };
+          if (contentType && !types.includes(contentType)) return { results: [], pagination: { page, pageSize, total: 0, pageCount: 0 } };
+          const [results, total] = await Promise.all([
+            rows().findMany({
+              select: ["id", "contentType", "relatedDocumentId", "title", "locales", "actor", "actorName", "deletedAt", "expiresAt", "status", "restoredAs", "restoredAt"],
+              where,
+              orderBy: [{ deletedAt: "desc" }, { id: "desc" }],
+              offset: (page - 1) * pageSize,
+              limit: pageSize
+            }),
+            rows().count({ where })
+          ]);
+          return { results, pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) } };
+        },
+        async find(id) {
+          return rows().findOne({ where: { id } });
+        },
+        // One row for the preview: fields and blocks of each entry, and how many links it held.
+        preview(row) {
+          const schema = schemaOf(row.contentType);
+          const { entries, incoming, ...meta } = row;
+          return {
+            ...meta,
+            incoming: (incoming || []).length,
+            entries: (entries || []).map((entry) => ({ locale: entry.locale ?? null, status: entry.status ?? null, ...previewOf(entry.snapshot, schema, schemaOf) }))
+          };
+        },
+        // The pre-check: every lookup a restore needs, then planRestore. Read-only; the restore runs it again in its transaction.
+        async plan(row) {
+          const uid = row.contentType, schema = schemaOf(uid);
+          if (!schema || !strapi.contentTypes?.[uid]) return { blocking: [{ code: "typeGone" }], warnings: [], steps: [], incoming: { links: [], gone: 0, published: 0, replaced: 0 } };
+          const i18n = localized(uid);
+          const locales = i18n ? (await strapi.plugin("i18n").service("locales").find()).map((locale) => locale.code) : null;
+          const defaultLocale = i18n ? await strapi.plugin("i18n").service("locales").getDefaultLocale() : null;
+          const current = await strapi.db.query(uid).findMany({ select: ["locale"], where: { documentId: row.relatedDocumentId } });
+          const existing = current.length ? [...new Set(current.map((entry) => i18n ? entry.locale : null))] : null;
+          const singleTaken = schema.kind === "singleType" && !existing && Boolean(await strapi.db.query(uid).findOne({ select: ["id"] }));
+          const chosen = [...chooseEntries(row.entries).values()];
+          const { media, relation } = await lookups(uid, chosen.map((entry) => entry.snapshot));
+          const taken = /* @__PURE__ */ new Set();
+          for (const entry of chosen) for (const field of uniqueFields(schema)) {
+            const value = entry.snapshot?.[field];
+            if (blank(value) || typeof value === "object") continue;
+            const other = await strapi.db.query(uid).findOne({ select: ["id"], where: { [field]: value, ...i18n && { locale: entry.locale }, ...existing && { documentId: { $ne: row.relatedDocumentId } } } });
+            if (other) taken.add(stable([field, entry.locale ?? null, value]));
+          }
+          const plan = planRestore(row.entries, { schema, schemaOf, locales, defaultLocale, existing, singleTaken, media, relation, taken: (field, locale, value) => taken.has(stable([field, locale ?? null, value])) });
+          const incoming = await strapi.db.transaction(({ trx }) => resolveIncoming(uid, row.incoming, plan.steps.map((step) => step.locale), trx));
+          return { ...plan, documentId: existing ? row.relatedDocumentId : null, incoming };
+        },
+        // What the pre-check endpoint returns: the plan without the data it would write.
+        async check(row) {
+          if (row.status !== "trashed") return { status: row.status, restoredAs: row.restoredAs, blocking: [{ code: "restored" }], warnings: [] };
+          const { steps, incoming: { links, ...incoming }, ...plan } = await self.plan(row);
+          return { ...plan, locales: steps.map((step) => step.locale), incoming: { ...incoming, reconnect: links.length } };
+        },
+        // Restore as a draft, in one transaction: claim the row (a second restore of the same row, concurrent or later, gets
+        // `already` with the first one's document), check again, recreate (default locale first, the others under the same
+        // documentId), put the links back, record `restore` events. A blocking problem throws `conflict` and nothing is written.
+        async restore(id, { actor, userId }) {
+          return restoring.run(true, () => strapi.db.transaction(async ({ trx }) => {
+            const claimed = await rows().updateMany({ where: { id, status: "trashed" }, data: { status: "restored", restoredAt: /* @__PURE__ */ new Date() } });
+            const row = await rows().findOne({ where: { id } });
+            if (!row) return null;
+            if (!claimed?.count) return { already: true, documentId: row.restoredAs || null };
+            const plan = await self.plan(row);
+            if (plan.blocking.length) {
+              const error = new Error("conflict");
+              error.conflict = { blocking: plan.blocking, warnings: plan.warnings };
+              throw error;
+            }
+            const uid = row.contentType, documents = strapi.documents(uid);
+            const creator = userId ? { createdBy: userId, updatedBy: userId } : {};
+            let documentId = plan.documentId;
+            for (const { locale, data } of plan.steps) {
+              const params = { ...locale && { locale }, data: { ...data, ...creator } };
+              if (documentId) await documents.update({ documentId, ...params });
+              else documentId = (await documents.create(params)).documentId;
+            }
+            const restored = await events().rows(uid, documentId, localized(uid) ? plan.steps.map((step) => step.locale) : null);
+            const rowOf = new Map(restored.map((entry) => [entry.locale ?? null, entry]));
+            for (const link of plan.incoming.links) {
+              const target = rowOf.get(link.locale);
+              if (!target) continue;
+              const { joinColumn, inverseJoinColumn, orderColumnName } = link.joinTable;
+              await table(trx, link.joinTable.name).insert({ [joinColumn.name]: link.ownerRowId, [inverseJoinColumn.name]: target.id, ...orderColumnName && link.order != null && { [orderColumnName]: link.order } });
+            }
+            for (const entry of restored) await events().record({ uid, documentId, locale: entry.locale ?? null, action: "restore", entry, actor, extra: { restoredFrom: row.relatedDocumentId, trash: row.id } });
+            await rows().update({ where: { id }, data: { restoredAs: documentId } });
+            const { links, ...incoming } = plan.incoming;
+            return { documentId, locales: plan.steps.map((step) => step.locale), warnings: plan.warnings, incoming: { ...incoming, reconnected: links.length } };
+          }));
+        },
+        // Delete forever (one row), recorded as a `purge` event. Never touches media files.
+        async remove(row, actor) {
+          return strapi.db.transaction(async () => {
+            const { count } = await rows().deleteMany({ where: { id: row.id } });
+            if (count) await events().record({ uid: row.contentType, documentId: row.relatedDocumentId, action: "purge", actor, extra: { trash: row.id, title: row.title } });
+            return count;
+          });
+        },
+        // Nightly, in batches, idempotent: rows past expiresAt are deleted (restored ones too). Never touches media files.
+        async purge(now = Date.now()) {
+          let count = 0;
+          for (; ; ) {
+            const ids = (await rows().findMany({ select: ["id"], where: { expiresAt: { $lt: new Date(now) } }, orderBy: { id: "asc" }, limit: BATCH })).map((row) => row.id);
+            if (ids.length) await rows().deleteMany({ where: { id: { $in: ids } } });
+            count += ids.length;
+            if (ids.length < BATCH) return count;
+          }
+        }
+      };
+      return self;
+    }
+    var ID = /^[1-9]\d{0,15}$/;
+    var API_UID = /^api::[\w-]+\.[\w-]+$/;
+    var int = (value, fallback, max) => {
+      if (value === void 0 || value === "") return fallback;
+      const n = Number(value);
+      return Number.isInteger(n) && n >= 1 && n <= max ? n : NaN;
+    };
+    var trashController2 = ({ strapi }) => {
+      const service = () => strapi.plugin(PLUGIN2).service("trash");
+      const { can, readableTypes, actorOf } = history();
+      const load = async (ctx, action = "read") => {
+        if (!ID.test(String(ctx.params?.id || ""))) {
+          ctx.badRequest("Invalid trash entry");
+          return null;
+        }
+        const row = await service().find(Number(ctx.params.id));
+        if (!row || !can(strapi, ctx, row.contentType, "read") || action !== "read" && !can(strapi, ctx, row.contentType, action)) {
+          ctx.notFound();
+          return null;
+        }
+        return row;
+      };
+      return {
+        async list(ctx) {
+          const { contentType = "", status = "trashed" } = ctx.query || {};
+          const page = int(ctx.query?.page, 1, 1e4), pageSize = int(ctx.query?.pageSize, 20, 100);
+          if (typeof contentType !== "string" || contentType && !API_UID.test(contentType) || !STATUSES.includes(status) || Number.isNaN(page) || Number.isNaN(pageSize)) return ctx.badRequest("Invalid filters");
+          const types = readableTypes(strapi, ctx);
+          ctx.body = {
+            ...await service().list({ contentType, status, page, pageSize, types }),
+            types: types.map((uid) => ({ uid, displayName: strapi.contentTypes[uid].info?.displayName || uid, kind: strapi.contentTypes[uid].kind, localized: Boolean(strapi.contentTypes[uid].pluginOptions?.i18n?.localized) }))
+          };
+        },
+        async find(ctx) {
+          const row = await load(ctx);
+          if (row) ctx.body = service().preview(row);
+        },
+        async check(ctx) {
+          const row = await load(ctx, "create");
+          if (row) ctx.body = await service().check(row);
+        },
+        async restore(ctx) {
+          const row = await load(ctx, "create");
+          if (!row) return;
+          try {
+            const result = await service().restore(row.id, { actor: actorOf(strapi), userId: ctx.state?.user?.id });
+            if (!result) return ctx.notFound();
+            ctx.body = result;
+          } catch (error) {
+            if (!error?.conflict) throw error;
+            ctx.status = 409;
+            ctx.body = { data: null, error: { status: 409, name: "ConflictError", message: "The document cannot be restored as it is: nothing was written.", details: error.conflict } };
+          }
+        },
+        async remove(ctx) {
+          const row = await load(ctx, "delete");
+          if (!row) return;
+          ctx.body = { deleted: await service().remove(row, actorOf(strapi)) };
+        }
+      };
+    };
+    module2.exports = { TRASH_UID, STATUSES, restoring, trashContentType: trashContentType2, expiresAt, uniqueFields, chooseEntries, restorePayload, planRestore, incomingSources, incomingRows, previewOf, trashService: trashService2, trashController: trashController2 };
+  }
+});
+
+// server/history.js
+var require_history = __commonJS({
+  "server/history.js"(exports2, module2) {
+    "use strict";
+    var { createHash } = require("node:crypto");
+    var { PLUGIN: PLUGIN2 } = require_settings();
+    var { snapshotPopulate, canonical, stable, summarize } = require_diff();
+    var { TRASH_UID, restoring } = require_trash();
+    var EVENT_UID = `plugin::${PLUGIN2}.event`;
+    var ACTIONS = ["create", "update", "publish", "unpublish", "discard", "delete", "restore", "purge"];
+    var CAPTURED = { create: "create", clone: "create", update: "update", publish: "publish", unpublish: "unpublish", discardDraft: "discard", delete: "delete" };
+    var CRON2 = "blocksceneHistoryPurge";
+    var BATCH = 500;
+    var DAY = 24 * 60 * 60 * 1e3;
+    var LIST_LIMIT = 100;
+    var ACTORS_LIMIT = 500;
+    var SEARCH_LIMIT = 200;
+    var eventContentType2 = { schema: {
+      kind: "collectionType",
+      collectionName: "blockscene_events",
+      info: { singularName: "event", pluralName: "events", displayName: "Blockscene event" },
+      options: { draftAndPublish: false },
+      pluginOptions: { "content-manager": { visible: false }, "content-type-builder": { visible: false }, i18n: { localized: false } },
+      attributes: {
+        contentType: { type: "string", required: true },
+        relatedDocumentId: { type: "string", required: true },
+        locale: { type: "string" },
+        action: { type: "enumeration", enum: ACTIONS, required: true },
+        // 'admin:<id>', 'token:<id>', 'user:<id>' (Users & Permissions) or 'system'; the name as it was at that moment.
+        actor: { type: "string", required: true },
+        actorName: { type: "string" },
+        at: { type: "datetime", required: true },
+        // { fields: [names], blocks: { added, removed, changed }, initial? } vs the previous snapshot; { missing: true } when the capture failed;
+        // restore: + { restoredFrom, trash }; purge: { trash, title }.
+        summary: { type: "json" },
+        // Null when identical to the previous snapshot of the same locale (same hash) or purged.
+        snapshot: { type: "json" },
+        hash: { type: "string" },
+        size: { type: "integer" }
+      },
+      indexes: [{ name: "blockscene_events_lookup", columns: ["content_type", "related_document_id", "locale", "at"] }]
+    } };
+    var fail2 = (message, Kind = "ApplicationError") => {
+      let E;
+      try {
+        E = require("@strapi/utils").errors[Kind];
+      } catch {
+        E = class extends Error {
+          constructor(m) {
+            super(m);
+            this.name = Kind;
+          }
+        };
+      }
+      throw new E(message);
+    };
+    var hashOf = (text) => createHash("sha256").update(text).digest("hex");
+    var covers2 = (history, uid) => Boolean(history?.enabled) && uid.startsWith("api::") && (history.contentTypes === "all" || Array.isArray(history.contentTypes) && history.contentTypes.includes(uid));
+    var retention = ({ retentionDays, eventDays }, now = Date.now()) => ({ snapshotsBefore: new Date(now - retentionDays * DAY), eventsBefore: new Date(now - eventDays * DAY) });
+    function actorOf(strapi) {
+      let ctx;
+      try {
+        ctx = strapi.requestContext?.get?.();
+      } catch {
+        ctx = null;
+      }
+      const strategy = ctx?.state?.auth?.strategy?.name, user = ctx?.state?.user, token = ctx?.state?.auth?.credentials;
+      const name = (value) => String(value || "").slice(0, 255);
+      if (strategy === "admin" && user?.id) return { actor: `admin:${user.id}`, actorName: name([user.firstname, user.lastname].filter(Boolean).join(" ") || user.username || user.email) };
+      if (strategy === "api-token" && token?.id) return { actor: `token:${token.id}`, actorName: name(token.name) };
+      if (user?.id) return { actor: `user:${user.id}`, actorName: name(user.username || user.email) };
+      return { actor: "system", actorName: "" };
+    }
+    function refsOf(snapshot, schema, schemaOf) {
+      const media = /* @__PURE__ */ new Set(), relations = [];
+      const walk = (data, schema2, depth) => {
+        if (!data || typeof data !== "object" || depth > 20) return;
+        for (const [name, attr] of Object.entries(schema2?.attributes || {})) {
+          const value = data[name];
+          if (value == null) continue;
+          const list = Array.isArray(value) ? value : [value];
+          if (attr.type === "media") list.forEach((id) => Number.isInteger(id) && media.add(id));
+          else if (attr.type === "relation" && attr.target) list.forEach((ref) => ref?.documentId && relations.push({ target: attr.target, ...ref }));
+          else if (attr.type === "component") list.forEach((item) => walk(item, schemaOf(attr.component), depth + 1));
+          else if (attr.type === "dynamiczone") list.forEach((row) => walk(row, schemaOf(row?.__component), depth + 1));
+        }
+      };
+      walk(snapshot, schema, 0);
+      return { media: [...media], relations };
+    }
+    function historyService2({ strapi }) {
+      const plugin = () => strapi.plugin(PLUGIN2);
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const localized = (uid) => Boolean(schemaOf(uid)?.pluginOptions?.i18n?.localized);
+      const draftAndPublish = (uid) => schemaOf(uid)?.options?.draftAndPublish === true;
+      const events = () => strapi.db.query(EVENT_UID);
+      const actors = async () => {
+        const meta = strapi.db.metadata.get(EVENT_UID);
+        const column = (name) => meta.attributes[name].columnName || name;
+        return strapi.db.connection(meta.tableName).select({ actor: column("actor") }).max({ actorName: column("actorName") }).groupBy(column("actor")).orderBy(column("actor")).limit(ACTORS_LIMIT);
+      };
+      const scope = async (uid, locale) => {
+        if (!localized(uid)) return [null];
+        if (locale === "*") return null;
+        if (Array.isArray(locale) && locale.length) return locale;
+        if (typeof locale === "string" && locale) return [locale];
+        return [await strapi.plugin("i18n").service("locales").getDefaultLocale()];
+      };
+      const rows = async (uid, documentId, locales, published = false) => !documentId ? [] : strapi.db.query(uid).findMany({
+        where: {
+          documentId,
+          ...locales && localized(uid) && { locale: { $in: locales } },
+          ...draftAndPublish(uid) && { publishedAt: published ? { $notNull: true } : { $null: true } }
+        },
+        populate: snapshotPopulate(uid, schemaOf)
+      });
+      const self = {
+        EVENT_UID,
+        async config() {
+          return (await plugin().service("settings").get()).history;
+        },
+        covers: covers2,
+        // One event. The snapshot is stored unless identical to the latest stored one of the same document and locale.
+        async record({ uid, documentId, locale = null, action, entry, actor, missing = false, extra = null }) {
+          let summary = missing ? { missing: true } : null, snapshot = null, hash = null, size = 0;
+          if (entry) {
+            const content = canonical(entry, schemaOf(uid), schemaOf);
+            const text = stable(content);
+            hash = hashOf(text);
+            const previous = await events().findOne({ select: ["hash", "snapshot"], where: { contentType: uid, relatedDocumentId: documentId, locale, size: { $gt: 0 } }, orderBy: [{ at: "desc" }, { id: "desc" }] });
+            summary = summarize(previous?.snapshot || null, content, schemaOf(uid));
+            if (previous?.hash !== hash) {
+              snapshot = content;
+              size = Buffer.byteLength(text);
+            }
+          }
+          if (extra) summary = { ...summary, ...extra };
+          return events().create({ data: { contentType: uid, relatedDocumentId: documentId, locale, action, ...actor, at: /* @__PURE__ */ new Date(), summary, snapshot, hash, size } });
+        },
+        // After a save or publish: one event per affected entry (drafts, or the published versions after a publish).
+        async captureSave({ uid, action, documentId, locales, published, actor }) {
+          if (!documentId) return;
+          for (const entry of await rows(uid, documentId, locales, published)) await self.record({ uid, documentId, locale: entry.locale ?? null, action, entry, actor });
+        },
+        scope,
+        rows,
+        // The Content Manager's main field of a content type when it is a plain value (what list views show), else null.
+        async mainField(uid) {
+          let name = null;
+          try {
+            name = (await strapi.plugin("content-manager").service("content-types").findConfiguration(strapi.contentTypes[uid]))?.settings?.mainField;
+          } catch {
+            name = null;
+          }
+          return name && name !== "id" && schemaOf(uid)?.attributes?.[name] && !["relation", "media", "component", "dynamiczone", "password", "json", "blocks"].includes(schemaOf(uid).attributes[name].type) ? name : null;
+        },
+        // Latest events of one document and locale, newest first; `stored`: its snapshot (or an identical one) can be loaded.
+        async list({ uid, documentId, locale }) {
+          const where = { contentType: uid, relatedDocumentId: documentId, locale: locale || null };
+          const [list, kept] = await Promise.all([
+            events().findMany({ select: ["id", "action", "actor", "actorName", "at", "summary", "hash", "size"], where, orderBy: [{ at: "desc" }, { id: "desc" }], limit: LIST_LIMIT }),
+            events().findMany({ select: ["hash"], where: { ...where, size: { $gt: 0 } } })
+          ]);
+          const hashes = new Set(kept.map((row) => row.hash));
+          return list.map(({ hash, size, ...event }) => ({ ...event, stored: Boolean(hash && hashes.has(hash)) }));
+        },
+        // One event with its snapshot (from an identical event when this one was deduplicated) and what loading it needs:
+        // the media files and relation targets that still exist (relation labels from the Content Manager's main field).
+        async find(id) {
+          const event = await events().findOne({ where: { id } });
+          if (!event) return null;
+          const { snapshot: own, ...meta } = event;
+          const snapshot = own || event.hash && (await events().findOne({ select: ["snapshot"], where: { contentType: event.contentType, relatedDocumentId: event.relatedDocumentId, locale: event.locale, hash: event.hash, size: { $gt: 0 } } }))?.snapshot || null;
+          if (!snapshot) return { event: meta, snapshot: null, media: {}, relations: {} };
+          const refs = refsOf(snapshot, schemaOf(event.contentType), schemaOf);
+          const files = refs.media.length ? await strapi.db.query("plugin::upload.file").findMany({ where: { id: { $in: refs.media } } }) : [];
+          const relations = {};
+          for (const target of [...new Set(refs.relations.map((ref) => ref.target))]) {
+            if (!strapi.contentTypes?.[target]) continue;
+            const mainField = await self.mainField(target), scalar = Boolean(mainField);
+            const found = await strapi.db.query(target).findMany({
+              select: ["id", "documentId", "locale", ...scalar ? [mainField] : []],
+              where: { documentId: { $in: [...new Set(refs.relations.filter((ref) => ref.target === target).map((ref) => ref.documentId))] }, ...draftAndPublish(target) && { publishedAt: { $null: true } } }
+            });
+            relations[target] = found.map((row) => ({ id: row.id, documentId: row.documentId, locale: row.locale || null, label: scalar && row[mainField] != null ? String(row[mainField]) : void 0, mainField: scalar ? mainField : void 0 }));
+          }
+          return { event: meta, snapshot, media: Object.fromEntries(files.map((file) => [file.id, file])), relations };
+        },
+        // Content activity: one page of events (no snapshots), newest first, with each document's title and whether it still
+        // exists (the list links to it). `types`: the content types the user may read. `q`: documents whose main field
+        // contains it now, or whose trash entry's title does (at most SEARCH_LIMIT per content type).
+        async activity({ actor, contentType, action, from, to, q, page, pageSize, types }) {
+          const empty = { results: [], pagination: { page, pageSize, total: 0, pageCount: 0 }, actors: [] };
+          if (contentType && !types.includes(contentType)) return empty;
+          const where = {
+            contentType: contentType || { $in: types },
+            ...actor && { actor },
+            ...action && { action },
+            ...(from || to) && { at: { ...from && { $gte: from }, ...to && { $lte: to } } }
+          };
+          if (q) {
+            const matches = [];
+            for (const uid of contentType ? [contentType] : types) {
+              const main = await self.mainField(uid);
+              const found = new Set(main ? (await strapi.db.query(uid).findMany({ select: ["documentId"], where: { [main]: { $containsi: q } }, limit: SEARCH_LIMIT })).map((row) => row.documentId) : []);
+              for (const row of await strapi.db.query(TRASH_UID).findMany({ select: ["relatedDocumentId"], where: { contentType: uid, title: { $containsi: q } }, limit: SEARCH_LIMIT })) found.add(row.relatedDocumentId);
+              if (found.size) matches.push({ contentType: uid, relatedDocumentId: { $in: [...found] } });
+            }
+            if (!matches.length) return { ...empty, actors: await actors() };
+            where.$or = matches;
+          }
+          const [list, total] = await Promise.all([
+            events().findMany({ select: ["id", "contentType", "relatedDocumentId", "locale", "action", "actor", "actorName", "at", "summary"], where, orderBy: [{ at: "desc" }, { id: "desc" }], offset: (page - 1) * pageSize, limit: pageSize }),
+            events().count({ where })
+          ]);
+          const docs = /* @__PURE__ */ new Map();
+          for (const uid of [...new Set(list.map((event) => event.contentType))]) {
+            const ids = [...new Set(list.filter((event) => event.contentType === uid).map((event) => event.relatedDocumentId))];
+            const main = strapi.contentTypes?.[uid] ? await self.mainField(uid) : null;
+            const found = strapi.contentTypes?.[uid] ? await strapi.db.query(uid).findMany({ select: ["documentId", "locale", ...main ? [main] : []], where: { documentId: { $in: ids } } }) : [];
+            for (const row of found) {
+              const key = `${uid}|${row.documentId}`;
+              docs.set(key, [...docs.get(key) || [], { locale: row.locale ?? null, title: main && row[main] != null ? String(row[main]) : null }]);
+            }
+            const gone = ids.filter((id) => !docs.has(`${uid}|${id}`));
+            if (gone.length) {
+              for (const row of await strapi.db.query(TRASH_UID).findMany({ select: ["relatedDocumentId", "title"], where: { contentType: uid, relatedDocumentId: { $in: gone } }, orderBy: { id: "desc" } }))
+                if (!docs.has(`trash|${uid}|${row.relatedDocumentId}`)) docs.set(`trash|${uid}|${row.relatedDocumentId}`, row.title);
+            }
+          }
+          const results = list.map((event) => {
+            const rows2 = docs.get(`${event.contentType}|${event.relatedDocumentId}`) || [];
+            const own = rows2.find((row) => row.locale === (event.locale ?? null));
+            if (event.action === "purge") return { ...event, exists: false, title: event.summary?.title ?? null };
+            return { ...event, exists: Boolean(own), title: (own || rows2[0])?.title ?? docs.get(`trash|${event.contentType}|${event.relatedDocumentId}`) ?? null };
+          });
+          return { results, pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) }, actors: await actors() };
+        },
+        // Nightly, in batches, idempotent (two instances running it is harmless): events past eventDays are deleted;
+        // snapshots past retentionDays, or beyond maxSnapshots per document (newest kept), are emptied. Never touches media.
+        async purge(now = Date.now()) {
+          const history = await self.config();
+          const { snapshotsBefore, eventsBefore } = retention(history, now);
+          const counts = { events: 0, expired: 0, excess: 0 };
+          const batches = async (key, query, apply) => {
+            for (; ; ) {
+              const ids = (await events().findMany({ select: ["id"], limit: BATCH, ...query })).map((row) => row.id);
+              if (ids.length) await apply({ id: { $in: ids } });
+              counts[key] += ids.length;
+              if (ids.length < BATCH) return;
+            }
+          };
+          const empty = (where) => events().updateMany({ where, data: { snapshot: null, size: 0 } });
+          await batches("events", { where: { at: { $lt: eventsBefore } }, orderBy: { id: "asc" } }, (where) => events().deleteMany({ where }));
+          await batches("expired", { where: { at: { $lt: snapshotsBefore }, size: { $gt: 0 } }, orderBy: { id: "asc" } }, empty);
+          const meta = strapi.db.metadata.get(EVENT_UID);
+          const column = (name) => meta.attributes[name].columnName || name;
+          const crowded = await strapi.db.connection(meta.tableName).select({ uid: column("contentType"), documentId: column("relatedDocumentId") }).where(column("size"), ">", 0).groupBy(column("contentType"), column("relatedDocumentId")).havingRaw("count(*) > ?", [history.maxSnapshots]);
+          for (const { uid, documentId } of crowded) await batches("excess", {
+            where: { contentType: uid, relatedDocumentId: documentId, size: { $gt: 0 } },
+            orderBy: [{ at: "desc" }, { id: "desc" }],
+            offset: history.maxSnapshots
+          }, empty);
+          return counts;
+        }
+      };
+      return self;
+    }
+    function registerHistory2(strapi) {
+      if (!strapi.documents?.use) return;
+      const service = () => strapi.plugin(PLUGIN2).service("history");
+      const warn = (message, error) => strapi.log.error(`[${PLUGIN2}] ${message}: ${error?.message || error}`);
+      strapi.documents.use(async (ctx, next) => {
+        const action = CAPTURED[ctx.action];
+        if (!action || !String(ctx.uid || "").startsWith("api::") || strapi.plugin(PLUGIN2).config("disabled") === true || restoring.getStore()) return next();
+        const history = service();
+        const params = ctx.params || {};
+        if (action === "delete") {
+          const config = params.documentId ? await history.config() : null;
+          if (!config || !history.covers(config, ctx.uid)) return next();
+          return strapi.db.transaction(async () => {
+            const actor2 = actorOf(strapi), trash = strapi.plugin(PLUGIN2).service("trash");
+            const published = strapi.getModel(ctx.uid)?.options?.draftAndPublish === true;
+            let locales2, entries, live, incoming;
+            try {
+              locales2 = await history.scope(ctx.uid, params.locale);
+              entries = await history.rows(ctx.uid, params.documentId, locales2);
+              live = published ? await history.rows(ctx.uid, params.documentId, locales2, true) : [];
+              incoming = await trash.incoming(ctx.uid, new Map([...entries.map((row) => [row.id, { locale: row.locale, published: false }]), ...live.map((row) => [row.id, { locale: row.locale, published: true }])]));
+            } catch (error) {
+              warn("reading the document before a delete failed", error);
+              fail2(`The version history could not record this delete, so nothing was deleted (${error.message}).`);
+            }
+            const result2 = await next();
+            try {
+              for (const entry of entries) await history.record({ uid: ctx.uid, documentId: params.documentId, locale: entry.locale ?? null, action, entry, actor: actor2 });
+              if (entries.length || live.length) await trash.record({ uid: ctx.uid, documentId: params.documentId, locales: locales2, drafts: entries, published: live, incoming, actor: actor2, days: config.trashDays });
+            } catch (error) {
+              warn("recording a delete failed, the delete was rolled back", error);
+              fail2(`The version history could not record this delete, so nothing was deleted (${error.message}).`);
+            }
+            return result2;
+          });
+        }
+        let covered = false;
+        try {
+          covered = history.covers(await history.config(), ctx.uid);
+        } catch (error) {
+          warn("reading the history settings failed, this change is not recorded", error);
+        }
+        if (!covered) return next();
+        const actor = actorOf(strapi);
+        const result = await next();
+        const documentId = ["create", "update"].includes(action) ? result?.documentId || params.documentId : params.documentId;
+        const locales = ["publish", "unpublish", "discard"].includes(action) ? [...new Set((result?.entries || []).map((entry) => entry?.locale ?? null))] : ctx.action === "clone" ? null : await history.scope(ctx.uid, params.locale).catch(() => [result?.locale ?? null]);
+        const steps = [[action, action === "publish"]];
+        if (["create", "update"].includes(ctx.action) && params.status === "published" && strapi.getModel(ctx.uid)?.options?.draftAndPublish) steps.push(["publish", true]);
+        for (const [step, published] of steps) {
+          if (locales && !locales.length) continue;
+          try {
+            await history.captureSave({ uid: ctx.uid, action: step, documentId, locales, published, actor });
+          } catch (error) {
+            warn(`recording "${step}" of ${ctx.uid} ${documentId} failed, the change was saved without a version`, error);
+            try {
+              if (documentId) for (const locale of locales || [null]) await history.record({ uid: ctx.uid, documentId, locale, action: step, actor, missing: true });
+            } catch (again) {
+              warn("marking the missing version failed too", again);
+            }
+          }
+        }
+        return result;
+      });
+    }
+    function registerPurge2(strapi) {
+      if (!strapi.documents?.use || !strapi.cron?.add) return;
+      strapi.cron.add({ [CRON2]: { options: "0 3 * * *", task: async () => {
+        try {
+          const counts = await strapi.plugin(PLUGIN2).service("history").purge();
+          if (counts.events || counts.expired || counts.excess) strapi.log.info(`[${PLUGIN2}] history purge: ${counts.events} events deleted, ${counts.expired + counts.excess} snapshots emptied`);
+        } catch (error) {
+          strapi.log.error(`[${PLUGIN2}] history purge failed: ${error?.message || error}`);
+        }
+        try {
+          const count = await strapi.plugin(PLUGIN2).service("trash").purge();
+          if (count) strapi.log.info(`[${PLUGIN2}] trash purge: ${count} expired entries deleted`);
+        } catch (error) {
+          strapi.log.error(`[${PLUGIN2}] trash purge failed: ${error?.message || error}`);
+        }
+      } } });
+    }
+    var DOCUMENT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+    var LOCALE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+    var can = (strapi, ctx, uid, action = "read") => {
+      try {
+        return !strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: uid }).cannot[action]();
+      } catch {
+        return false;
+      }
+    };
+    var canRead = (strapi, ctx, uid) => can(strapi, ctx, uid);
+    var readableTypes = (strapi, ctx) => Object.keys(strapi.contentTypes || {}).filter((uid) => uid.startsWith("api::") && canRead(strapi, ctx, uid));
+    var ACTOR = /^(system|(admin|token|user):\d{1,15})$/;
+    var int = (value, fallback, max) => {
+      if (value === void 0 || value === "") return fallback;
+      const n = Number(value);
+      return Number.isInteger(n) && n >= 1 && n <= max ? n : NaN;
+    };
+    var date = (value) => {
+      if (!value) return null;
+      const time = Date.parse(value);
+      return typeof value === "string" && value.length <= 40 && Number.isFinite(time) ? new Date(time) : NaN;
+    };
+    var historyController2 = ({ strapi }) => ({
+      async list(ctx) {
+        const { uid, documentId } = ctx.params || {};
+        const locale = ctx.query?.locale || "";
+        if (!String(uid).startsWith("api::") || !strapi.contentTypes?.[uid] || !DOCUMENT_ID.test(documentId || "") || locale && !LOCALE.test(locale)) return ctx.badRequest("Invalid content type, document or locale");
+        if (!canRead(strapi, ctx, uid)) return ctx.forbidden();
+        const history = strapi.plugin(PLUGIN2).service("history");
+        ctx.body = { results: await history.list({ uid, documentId, locale: (await history.scope(uid, locale || void 0))[0] }) };
+      },
+      async find(ctx) {
+        const id = Number(ctx.params?.id);
+        if (!Number.isInteger(id) || id <= 0) return ctx.badRequest("Invalid event");
+        const found = await strapi.plugin(PLUGIN2).service("history").find(id);
+        if (!found || !canRead(strapi, ctx, found.event.contentType)) return ctx.notFound();
+        ctx.body = found;
+      },
+      async activity(ctx) {
+        const { actor = "", contentType = "", action = "", q = "" } = ctx.query || {};
+        const page = int(ctx.query?.page, 1, 1e4), pageSize = int(ctx.query?.pageSize, 25, 100), from = date(ctx.query?.from), to = date(ctx.query?.to);
+        if ([actor, contentType, action, q].some((value) => typeof value !== "string") || actor && !ACTOR.test(actor) || contentType && !/^api::[\w-]+\.[\w-]+$/.test(contentType) || action && !ACTIONS.includes(action) || q.length > 100 || [page, pageSize, from, to].some((value) => Number.isNaN(value))) return ctx.badRequest("Invalid filters");
+        const history = strapi.plugin(PLUGIN2).service("history");
+        const types = readableTypes(strapi, ctx);
+        ctx.body = {
+          ...await history.activity({ actor, contentType, action, from, to, q: q.trim(), page, pageSize, types }),
+          enabled: Boolean((await history.config()).enabled) && strapi.plugin(PLUGIN2).config("disabled") !== true,
+          types: types.map((uid) => ({ uid, displayName: strapi.contentTypes[uid].info?.displayName || uid, kind: strapi.contentTypes[uid].kind, localized: Boolean(strapi.contentTypes[uid].pluginOptions?.i18n?.localized) }))
+        };
+      }
+    });
+    module2.exports = { EVENT_UID, ACTIONS, CAPTURED, CRON: CRON2, BATCH, eventContentType: eventContentType2, covers: covers2, retention, actorOf, refsOf, can, readableTypes, historyService: historyService2, registerHistory: registerHistory2, registerPurge: registerPurge2, historyController: historyController2 };
   }
 });
 
 // server/index.js
-var { PLUGIN, TEMPLATES, DEFAULTS, catalog, validateSettings, mergeSaved, safeUrl, fail } = require_settings();
-var { safeGroups, validateGroups } = require_groups();
+var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, validateVariants, schemaMetadata, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
+var { safeGroups, validateGroups, invalidComponents, layoutFields } = require_groups();
+var { hiddenName, injectHidden, hideFromBuilder, registerHiddenStrip } = require_hidden();
+var { CRON, covers, eventContentType, historyService, historyController, registerHistory, registerPurge } = require_history();
+var { trashContentType, trashService, trashController } = require_trash();
+var STRAPI5 = true;
+var withHidden = [];
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
 var LEGACY_PLUGIN = "block-picker";
 async function readSettings(strapi) {
@@ -247,8 +1720,22 @@ async function resolveMedia(strapi, settings) {
   }
   return resolved;
 }
+var contentTypeUids = (strapi) => Object.fromEntries(Object.entries(strapi.contentTypes || {}).filter(([uid, schema]) => uid.startsWith("api::") && zonesOf(schema).length).map(([uid, schema]) => [uid, Object.keys(schema.attributes || {})]));
+var apiUids = (strapi) => Object.keys(strapi.contentTypes || {}).filter((uid) => uid.startsWith("api::"));
 var zonesOf = (schema) => Object.entries(schema?.attributes || {}).filter(([, attr]) => attr?.type === "dynamiczone").map(([name]) => name);
 var label = (error) => `row ${error.index + 1}: ${error.code === "closeBeforeOpen" ? `close marker ${error.uid} has no open marker before it` : error.code === "mismatch" ? `close marker ${error.uid} does not match the open group ${error.open} (expected ${error.expected})` : `group ${error.uid} is not closed (expected ${error.expected})`}`;
+var componentLabel = (error) => `row ${error.index + 1}: component "${error.uid}" is not allowed in this Dynamic Zone`;
+function checkComponents(strapi, uid, entry) {
+  const schema = strapi.getModel(uid);
+  for (const name of zonesOf(schema)) {
+    if (!Array.isArray(entry?.[name])) continue;
+    const errors = invalidComponents(entry[name], schema.attributes[name].components);
+    if (errors.length) fail(
+      `Block components in "${name}" are not allowed by its schema (${errors.map(componentLabel).join("; ")}).`,
+      { plugin: PLUGIN, field: name, errors: errors.map((error) => ({ path: [name, error.index], message: componentLabel(error), name: "ValidationError", code: "componentNotAllowed", uid: error.uid })) }
+    );
+  }
+}
 function checkZones(strapi, uid, entry, groups) {
   for (const name of zonesOf(strapi.getModel(uid))) {
     const errors = validateGroups(Array.isArray(entry?.[name]) ? entry[name] : [], groups);
@@ -258,11 +1745,15 @@ function checkZones(strapi, uid, entry, groups) {
     );
   }
 }
-function registerPublishGuard(strapi) {
+function registerZoneGuards(strapi) {
   const plugin = strapi.plugin(PLUGIN);
   const groups = safeGroups(plugin.config("groups"), componentUids(strapi));
   if (plugin.config("groups") && !groups) strapi.log.warn(`[${PLUGIN}] "groups" config ignored: expected { "<open component uid>": "<close component uid>" } with existing components; every block is treated as ordinary.`);
-  if (!groups) return;
+  const active = async (uid) => {
+    if (plugin.config("disabled") === true) return false;
+    const settings = await plugin.service("settings").get();
+    return settings.editor.enabled && settings.contentTypes?.[uid]?.enabled !== false;
+  };
   if (strapi.documents?.use) {
     const defaultLocale = async () => {
       try {
@@ -274,12 +1765,14 @@ function registerPublishGuard(strapi) {
     strapi.documents.use(async (ctx, next) => {
       const { action, params = {} } = ctx;
       const publishing = action === "publish" || (action === "create" || action === "update") && params.status === "published";
-      if (!publishing || !ctx.uid) return next();
+      if (!ctx.uid || !["create", "update", "publish"].includes(action)) return next();
       const model = strapi.getModel(ctx.uid);
       const zones = zonesOf(model);
-      if (!zones.length) return next();
+      if (!zones.length || !await active(ctx.uid)) return next();
+      if (action === "create" || action === "update") checkComponents(strapi, ctx.uid, params.data || {});
+      if (!publishing) return next();
       if (action === "create") {
-        checkZones(strapi, ctx.uid, params.data || {}, groups);
+        if (groups) checkZones(strapi, ctx.uid, params.data || {}, groups);
         return next();
       }
       const populate = Object.fromEntries(zones.map((name) => [name, true]));
@@ -294,7 +1787,8 @@ function registerPublishGuard(strapi) {
       }
       for (const draft of drafts) {
         const entry = action === "update" ? { ...draft || {}, ...Object.fromEntries(zones.filter((name) => Array.isArray(params.data?.[name])).map((name) => [name, params.data[name]])) } : draft;
-        checkZones(strapi, ctx.uid, entry, groups);
+        checkComponents(strapi, ctx.uid, entry);
+        if (groups) checkZones(strapi, ctx.uid, entry, groups);
       }
       return next();
     });
@@ -303,20 +1797,31 @@ function registerPublishGuard(strapi) {
   const published = (data) => Boolean(data && data.publishedAt);
   strapi.db.lifecycles.subscribe({
     async beforeCreate(event) {
-      if (published(event.params?.data)) checkZones(strapi, event.model.uid, event.params.data, groups);
+      const data = event.params?.data, uid = event.model.uid;
+      if (!zonesOf(strapi.getModel(uid)).length || !await active(uid)) return;
+      checkComponents(strapi, uid, data || {});
+      if (groups && published(data)) checkZones(strapi, uid, data, groups);
     },
     async beforeUpdate(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length) return;
+      if (!zones.length || !await active(event.model.uid)) return;
+      checkComponents(strapi, event.model.uid, data || {});
+      if (!published(data)) return;
       const entry = zones.every((name) => Array.isArray(data[name])) ? data : { ...await strapi.entityService.findOne(event.model.uid, where?.id, { populate: zones }), ...data };
-      checkZones(strapi, event.model.uid, entry, groups);
+      checkComponents(strapi, event.model.uid, entry);
+      if (groups) checkZones(strapi, event.model.uid, entry, groups);
     },
     async beforeUpdateMany(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length) return;
-      for (const entry of await strapi.entityService.findMany(event.model.uid, { filters: where, populate: zones })) checkZones(strapi, event.model.uid, entry, groups);
+      if (!zones.length || !await active(event.model.uid)) return;
+      checkComponents(strapi, event.model.uid, data || {});
+      if (!published(data)) return;
+      for (const entry of await strapi.entityService.findMany(event.model.uid, { filters: where, populate: zones })) {
+        checkComponents(strapi, event.model.uid, entry);
+        if (groups) checkZones(strapi, event.model.uid, entry, groups);
+      }
     }
   });
 }
@@ -332,30 +1837,126 @@ module.exports = {
       blockPreview: false,
       // Optional layout groups: OPEN component uid -> its CLOSE uid, e.g. { 'wrappers.join': 'wrappers.close' }.
       // Empty/absent: every Dynamic Zone component is an ordinary block. See README "Layout groups".
-      groups: null
+      groups: null,
+      // Project defaults from code: same shape as the stored settings, e.g. require('./blockscene.json'). See README "Settings page".
+      settings: null,
+      // Edit view field texts from code (never stored): { uid: { attribute: { label, description, placeholder } } }. See README "Field labels".
+      fields: null,
+      // Other languages for the schema metadata (pluginOptions.blockscene, info.description), one flat map per locale:
+      // { 'pt-BR': require('./blockscene/pt-BR.json') }. See README "Describing blocks and fields in the schema".
+      translations: null,
+      // "Hide on the site": boolean attribute added to every Dynamic Zone component (a DB column); false adds nothing.
+      hiddenAttribute: "bsHidden"
     },
     validator: catalog
   },
+  // Before the database schema sync, so the column exists. A name the host already uses with another type is skipped.
+  register({ strapi }) {
+    const plugin = strapi.plugin(PLUGIN);
+    const name = hiddenName(plugin.config("hiddenAttribute"));
+    withHidden = [];
+    if (name === null) strapi.log.warn(`[${PLUGIN}] "hiddenAttribute" config ignored: expected a name like "bsHidden" or false. Hiding blocks is off.`);
+    if (!name) return;
+    const { added, skipped } = injectHidden(strapi.components, strapi.contentTypes, name);
+    withHidden = added;
+    if (skipped.length) strapi.log.warn(`[${PLUGIN}] "${name}" already exists with another type on ${skipped.join(", ")}; those blocks cannot be hidden.`);
+  },
   async bootstrap({ strapi }) {
     await strapi.admin.services.permission.actionProvider.registerMany([
       { section: "plugins", displayName: "Read gallery settings", uid: "settings.read", pluginName: PLUGIN },
-      { section: "plugins", displayName: "Change gallery settings", uid: "settings.update", pluginName: PLUGIN }
+      { section: "plugins", displayName: "Change gallery settings", uid: "settings.update", pluginName: PLUGIN },
+      ...STRAPI5 ? [
+        ["history.read", "Read version history"],
+        ["activity.read", "Read content activity"],
+        ["trash.read", "Read the trash"],
+        ["trash.restore", "Restore from the trash"],
+        ["trash.purge", "Delete from the trash forever"]
+      ].map(([uid, displayName]) => ({ section: "plugins", displayName, uid, pluginName: PLUGIN })) : []
     ]);
-    registerPublishGuard(strapi);
+    strapi.plugin(PLUGIN).service("settings").projectDefaults();
+    strapi.plugin(PLUGIN).service("settings").fields();
+    strapi.plugin(PLUGIN).service("settings").variants();
+    registerZoneGuards(strapi);
+    registerHiddenStrip(strapi, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")), strapi.plugin(PLUGIN));
+    if (withHidden.length) hideFromBuilder(typeof strapi.get === "function" ? strapi.get("services") : strapi.container.get("services"), withHidden, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")));
+    if (STRAPI5) {
+      registerHistory(strapi);
+      registerPurge(strapi);
+    }
   },
-  services: { settings: ({ strapi }) => ({
-    async get() {
-      return mergeSaved(await readSettings(strapi), componentUids(strapi));
-    },
-    async set(value) {
-      const next = validateSettings(value, componentUids(strapi));
-      for (const [uid, entry] of Object.entries(next.components)) {
-        if (entry.mediaId && !await findMedia(strapi, entry.mediaId).catch(() => null)) fail(`Media for "${uid}" does not exist`);
+  destroy({ strapi }) {
+    if (STRAPI5) strapi.cron?.remove?.(CRON);
+  },
+  // Version history events and the trash (Strapi 5): hidden from the Content Manager and the Content-Type Builder.
+  contentTypes: STRAPI5 ? { event: eventContentType, trash: trashContentType } : {},
+  services: { settings: ({ strapi }) => {
+    let project;
+    const projectDefaults = () => {
+      if (project !== void 0) return project;
+      const code = strapi.plugin(PLUGIN).config("settings");
+      project = null;
+      if (code) try {
+        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+      } catch (error) {
+        strapi.log?.warn(`[${PLUGIN}] "settings" config ignored: ${error.message}. Using the built-in defaults under the saved settings.`);
       }
-      await store(strapi).set({ key: "settings", value: next });
-      return next;
-    }
-  }) },
+      return project;
+    };
+    let meta;
+    const schemaMeta = () => {
+      if (meta !== void 0) return meta;
+      const notes = [];
+      meta = schemaMetadata({ ...strapi.contentTypes, ...strapi.components }, strapi.plugin(PLUGIN).config("translations"), notes);
+      if (notes.length) strapi.log?.warn(`[${PLUGIN}] schema metadata left out: ${notes.slice(0, 20).join("; ")}${notes.length > 20 ? `; and ${notes.length - 20} more` : ""}.`);
+      return meta;
+    };
+    let fields;
+    const fieldTexts = () => {
+      if (fields !== void 0) return fields;
+      const schemas = Object.fromEntries(Object.entries({ ...strapi.contentTypes, ...strapi.components }).map(([uid, schema]) => [uid, Object.keys(schema?.attributes || {})]));
+      const stale = [];
+      let code = {};
+      try {
+        code = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas, stale);
+      } catch (error) {
+        strapi.log?.warn(`[${PLUGIN}] "fields" config ignored: ${error.message}. Field labels fall back to the schema metadata and the Content Manager's own.`);
+      }
+      if (stale.length) strapi.log?.warn(`[${PLUGIN}] "fields" entries for fields the schema no longer has were skipped: ${stale.slice(0, 20).join(", ")}${stale.length > 20 ? ` and ${stale.length - 20} more` : ""}.`);
+      fields = structuredClone(schemaMeta().fields);
+      for (const [uid, entries] of Object.entries(code)) for (const [name, entry] of Object.entries(entries)) (fields[uid] ||= {})[name] = { ...fields[uid][name], ...entry };
+      return fields;
+    };
+    let variants;
+    const insertVariants = () => {
+      if (variants !== void 0) return variants;
+      const notes = [];
+      variants = validateVariants(strapi.plugin(PLUGIN).config("components"), strapi.components || {}, notes);
+      for (const note of notes) strapi.log?.warn(`[${PLUGIN}] components variants: ${note}.`);
+      return variants;
+    };
+    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+    return {
+      projectDefaults,
+      get,
+      fields: fieldTexts,
+      schema: schemaMeta,
+      variants: insertVariants,
+      async set(value) {
+        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+        for (const [uid, entry] of Object.entries(next.components)) {
+          if (entry.mediaId && !await findMedia(strapi, entry.mediaId).catch(() => null)) fail(`Media for "${uid}" does not exist`);
+        }
+        await store(strapi).set({ key: "settings", value: overrides(next, projectDefaults()) });
+        return next;
+      },
+      // Back to the project defaults (or the built-in ones); the legacy copy goes too, or it would be migrated again.
+      async reset() {
+        await store(strapi).delete({ key: "settings" });
+        await strapi.store({ type: "plugin", name: LEGACY_PLUGIN }).delete({ key: "settings" });
+        return get();
+      }
+    };
+  }, ...STRAPI5 && { history: historyService, trash: trashService } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -367,53 +1968,121 @@ module.exports = {
           disabled: plugin.config("disabled"),
           blockPreview: plugin.config("blockPreview"),
           groups: plugin.config("groups"),
-          componentUids: componentUids(strapi)
+          componentUids: componentUids(strapi),
+          schemas: strapi.components,
+          blocks: plugin.service("settings").schema().blocks
         });
         const settings = await plugin.service("settings").get();
         const media = await resolveMedia(strapi, settings);
+        for (const [uid, list] of Object.entries(plugin.service("settings").variants())) base.components[uid] = { ...base.components[uid], variants: list };
         for (const [uid, entry] of Object.entries(settings.components)) {
-          base.components[uid] = { ...base.components[uid], ...media[uid], template: entry.template };
+          base.components[uid] = {
+            ...base.components[uid],
+            ...media[uid],
+            template: entry.template,
+            ...entry.typology && { typology: entry.typology },
+            ...entry.tags && { tags: entry.tags }
+          };
         }
+        const hidden = hiddenName(plugin.config("hiddenAttribute")) || null;
+        const types = Object.fromEntries(Object.entries(strapi.contentTypes || {}).filter(([uid]) => !uid.startsWith("admin::")).map(([uid, schema]) => [uid, [schema.info?.displayName || "", ...Object.keys(schema.attributes || {})]]));
+        const history = STRAPI5 && strapi.documents?.use && !base.disabled && settings.history.enabled ? { contentTypes: apiUids(strapi).filter((uid) => covers(settings.history, uid)) } : null;
+        const layouts = Object.fromEntries(Object.entries(settings.components).filter(([uid, entry]) => entry.layout && base.groups?.[uid]).map(([uid, entry]) => [uid, entry.layout]));
         ctx.body = {
           ...base,
+          layouts,
           palette: settings.palette,
-          editor: { ...settings.editor, enabled: settings.editor.enabled && !base.disabled }
+          contentTypes: settings.contentTypes,
+          hiddenAttribute: hidden,
+          fields: plugin.service("settings").fields(),
+          types,
+          history,
+          editor: { ...settings.editor, enabled: settings.editor.enabled && !base.disabled, ...!hidden && { hiddenBlocks: "off" } }
         };
       }
     }),
     settings: ({ strapi }) => ({
       async find(ctx) {
         const settings = await strapi.plugin(PLUGIN).service("settings").get();
+        const auto = catalog({ components: strapi.plugin(PLUGIN).config("components"), schemas: strapi.components, blocks: strapi.plugin(PLUGIN).service("settings").schema().blocks }).components;
         const components = Object.entries(strapi.components || {}).map(([uid, schema]) => ({
           uid,
           displayName: schema.info?.displayName || uid,
-          category: schema.category || uid.split(".")[0]
+          category: schema.category || uid.split(".")[0],
+          typology: auto[uid]?.typology,
+          layoutFields: layoutFields(schema)
+        }));
+        const contentTypes = Object.keys(contentTypeUids(strapi)).map((uid) => ({
+          uid,
+          displayName: strapi.contentTypes[uid].info?.displayName || uid,
+          kind: strapi.contentTypes[uid].kind,
+          attributes: Object.entries(strapi.contentTypes[uid].attributes || {}).filter(([, attr]) => attr?.type !== "dynamiczone" && !attr?.private).map(([name, attr]) => ({ name, type: attr.type }))
         }));
         ctx.body = {
           settings,
           components,
+          contentTypes,
           media: await resolveMedia(strapi, settings),
           templates: TEMPLATES,
+          typologies: TYPOLOGIES,
           disabled: strapi.plugin(PLUGIN).config("disabled") === true,
+          hiddenAttribute: hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")) || null,
           blockPreviewAvailable: strapi.plugin(PLUGIN).config("blockPreview") === true,
-          defaults: DEFAULTS
+          defaults: DEFAULTS,
+          projectDefaults: strapi.plugin(PLUGIN).service("settings").projectDefaults(),
+          // Version history (Strapi 5 only): the content types it can cover.
+          historyTypes: STRAPI5 && strapi.documents?.use ? apiUids(strapi).map((uid) => ({ uid, displayName: strapi.contentTypes[uid].info?.displayName || uid })) : null
         };
       },
       async update(ctx) {
         ctx.body = await strapi.plugin(PLUGIN).service("settings").set(ctx.request?.body);
+      },
+      async reset(ctx) {
+        ctx.body = await strapi.plugin(PLUGIN).service("settings").reset();
       }
-    })
+    }),
+    prefs: ({ strapi }) => ({
+      async find(ctx) {
+        const id = ctx.state?.user?.id;
+        if (!id) return ctx.unauthorized();
+        ctx.body = mergePrefs(await store(strapi).get({ key: `prefs:${id}` }), componentUids(strapi));
+      },
+      async update(ctx) {
+        const id = ctx.state?.user?.id;
+        if (!id) return ctx.unauthorized();
+        const value = validatePrefs(ctx.request?.body, componentUids(strapi));
+        await store(strapi).set({ key: `prefs:${id}`, value });
+        ctx.body = value;
+      }
+    }),
+    ...STRAPI5 && { history: historyController, trash: trashController }
   },
   routes: { admin: { type: "admin", routes: [
     { method: "GET", path: "/catalog", handler: "catalog.find", config: { policies: ["admin::isAuthenticatedAdmin"] } },
-    ...["find", "update"].map((handler, index) => ({
-      method: index ? "PUT" : "GET",
+    ...["GET", "PUT"].map((method) => ({ method, path: "/me/prefs", handler: `prefs.${method === "GET" ? "find" : "update"}`, config: { policies: ["admin::isAuthenticatedAdmin"] } })),
+    ...[["GET", "find", "read"], ["PUT", "update", "update"], ["DELETE", "reset", "update"]].map(([method, handler, action]) => ({
+      method,
       path: "/settings",
       handler: `settings.${handler}`,
       config: { policies: ["admin::isAuthenticatedAdmin", {
         name: "admin::hasPermissions",
-        config: { actions: [`plugin::${PLUGIN}.settings.${index ? "update" : "read"}`] }
+        config: { actions: [`plugin::${PLUGIN}.settings.${action}`] }
       }] }
-    }))
+    })),
+    ...STRAPI5 ? [
+      ["GET", "/history/:uid/:documentId", "history.list", "history.read"],
+      ["GET", "/history-events/:id", "history.find", "history.read"],
+      ["GET", "/activity", "history.activity", "activity.read"],
+      ["GET", "/trash", "trash.list", "trash.read"],
+      ["GET", "/trash/:id", "trash.find", "trash.read"],
+      ["GET", "/trash/:id/check", "trash.check", "trash.restore"],
+      ["POST", "/trash/:id/restore", "trash.restore", "trash.restore"],
+      ["DELETE", "/trash/:id", "trash.remove", "trash.purge"]
+    ].map(([method, path, handler, action]) => ({
+      method,
+      path,
+      handler,
+      config: { policies: ["admin::isAuthenticatedAdmin", { name: "admin::hasPermissions", config: { actions: [`plugin::${PLUGIN}.${action}`] } }] }
+    })) : []
   ] } }
 };