@aduptive/strapi-blockscene 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/server.cjs

@@ -118,6 +118,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,11 +126,102 @@ 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
+      },
+      // 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.
+      history: { enabled: false, contentTypes: "all", retentionDays: 90, maxSnapshots: 100, eventDays: 365 }
+    };
+    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 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),
+      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
+    };
+    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 safeVersion = (value) => typeof value === "string" && /^[\w.-]{1,32}$/.test(value) ? value : void 0;
@@ -156,6 +248,15 @@ 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] ||= {};
+        entry.facets = facetsOf(uid, schema, config.schemas);
+        entry.typology ||= guessTypology(uid, schema?.info?.displayName);
+        entry.tags ||= [];
       }
       return {
         components: entries,
@@ -167,7 +268,8 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2) {
+    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = 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 +281,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) : 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)] : value;
       }
       const components = input.components || {};
       if (typeof components !== "object" || Array.isArray(components)) fail2("components must be an object");
@@ -193,6 +295,12 @@ 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;
@@ -200,9 +308,29 @@ var require_settings = __commonJS({
         }
         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);
+      }
+      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) {
+      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 +339,590 @@ 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 === "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 (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;
     }
-    module2.exports = { PLUGIN: PLUGIN2, TEMPLATES: TEMPLATES2, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, mergeSaved: mergeSaved2, safeUrl: safeUrl2, fail: fail2 };
+    var ENTRY_KEYS = ["components", "contentTypes"];
+    function layer2(base, saved) {
+      if (!base) return saved;
+      const doc = saved && typeof saved === "object" ? saved : {};
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => [key, { ...base[key], ...doc[key] && typeof doc[key] === "object" ? doc[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]));
+        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 };
+    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, text]) => LOCALE.test(locale) && fieldText(text, 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;
+    }
+    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, 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 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, 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/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 EVENT_UID = `plugin::${PLUGIN2}.event`;
+    var ACTIONS = ["create", "update", "publish", "unpublish", "discard", "delete", "restore"];
+    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 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.
+        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 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 }) {
+          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);
+            }
+          }
+          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,
+        // 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;
+            let mainField = null;
+            try {
+              mainField = (await strapi.plugin("content-manager").service("content-types").findConfiguration(strapi.contentTypes[target]))?.settings?.mainField;
+            } catch {
+              mainField = null;
+            }
+            const scalar = mainField && !["relation", "media", "component", "dynamiczone", "password"].includes(schemaOf(target)?.attributes?.[mainField]?.type) && mainField !== "id";
+            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 };
+        },
+        // 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) return next();
+        const history = service();
+        const params = ctx.params || {};
+        if (action === "delete") {
+          if (!params.documentId || !history.covers(await history.config(), ctx.uid)) return next();
+          return strapi.db.transaction(async () => {
+            const actor2 = actorOf(strapi);
+            let entries;
+            try {
+              entries = await history.rows(ctx.uid, params.documentId, await history.scope(ctx.uid, params.locale));
+            } 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 });
+            } 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}`);
+        }
+      } } });
+    }
+    var DOCUMENT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+    var LOCALE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+    var canRead = (strapi, ctx, uid) => {
+      try {
+        return !strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: uid }).cannot.read();
+      } catch {
+        return false;
+      }
+    };
+    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;
+      }
+    });
+    module2.exports = { EVENT_UID, ACTIONS, CAPTURED, CRON: CRON2, BATCH, eventContentType: eventContentType2, covers: covers2, retention, actorOf, refsOf, historyService: historyService2, registerHistory: registerHistory2, registerPurge: registerPurge2, historyController: historyController2 };
   }
 });
 
 // server/index.js
-var { PLUGIN, TEMPLATES, DEFAULTS, catalog, validateSettings, mergeSaved, safeUrl, fail } = require_settings();
+var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
 var { safeGroups, validateGroups } = require_groups();
+var { hiddenName, injectHidden, registerHiddenStrip } = require_hidden();
+var { CRON, covers, eventContentType, historyService, historyController, registerHistory, registerPurge } = require_history();
+var STRAPI5 = true;
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
 var LEGACY_PLUGIN = "block-picker";
 async function readSettings(strapi) {
@@ -247,6 +946,8 @@ 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})`}`;
 function checkZones(strapi, uid, entry, groups) {
@@ -263,6 +964,11 @@ function registerPublishGuard(strapi) {
   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 {
@@ -277,7 +983,7 @@ function registerPublishGuard(strapi) {
       if (!publishing || !ctx.uid) 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") {
         checkZones(strapi, ctx.uid, params.data || {}, groups);
         return next();
@@ -303,19 +1009,19 @@ 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);
+      if (published(event.params?.data) && await active(event.model.uid)) checkZones(strapi, event.model.uid, event.params.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 (!published(data) || !zones.length || !await active(event.model.uid)) 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);
     },
     async beforeUpdateMany(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length) return;
+      if (!published(data) || !zones.length || !await active(event.model.uid)) return;
       for (const entry of await strapi.entityService.findMany(event.model.uid, { filters: where, populate: zones })) checkZones(strapi, event.model.uid, entry, groups);
     }
   });
@@ -332,30 +1038,93 @@ 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,
+      // "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"));
+    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 { skipped } = injectHidden(strapi.components, strapi.contentTypes, name);
+    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 ? [{ section: "plugins", displayName: "Read version history", uid: "history.read", pluginName: PLUGIN }] : []
     ]);
+    strapi.plugin(PLUGIN).service("settings").projectDefaults();
+    strapi.plugin(PLUGIN).service("settings").fields();
     registerPublishGuard(strapi);
+    registerHiddenStrip(strapi, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")), strapi.plugin(PLUGIN));
+    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 (Strapi 5): hidden from the Content Manager and the Content-Type Builder.
+  contentTypes: STRAPI5 ? { event: eventContentType } : {},
+  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));
+      } 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 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 = [];
+      try {
+        fields = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas, stale);
+      } catch (error) {
+        fields = {};
+        strapi.log?.warn(`[${PLUGIN}] "fields" config ignored: ${error.message}. Field labels fall back to 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` : ""}.`);
+      return fields;
+    };
+    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi));
+    return {
+      projectDefaults,
+      get,
+      fields: fieldTexts,
+      async set(value) {
+        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(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`);
+        }
+        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 } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -367,53 +1136,107 @@ module.exports = {
           disabled: plugin.config("disabled"),
           blockPreview: plugin.config("blockPreview"),
           groups: plugin.config("groups"),
-          componentUids: componentUids(strapi)
+          componentUids: componentUids(strapi),
+          schemas: strapi.components
         });
         const settings = await plugin.service("settings").get();
         const media = await resolveMedia(strapi, settings);
         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;
         ctx.body = {
           ...base,
           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 }).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
+        }));
+        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 }
   },
   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 ? [["/history/:uid/:documentId", "list"], ["/history-events/:id", "find"]].map(([path, handler]) => ({
+      method: "GET",
+      path,
+      handler: `history.${handler}`,
+      config: { policies: ["admin::isAuthenticatedAdmin", { name: "admin::hasPermissions", config: { actions: [`plugin::${PLUGIN}.history.read`] } }] }
+    })) : []
   ] } }
 };