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

package/dist/server.cjs

@@ -144,11 +144,16 @@ var require_settings = __commonJS({
         confirmDelete: true,
         hiddenBlocks: "strip",
         duplicate: true,
-        clipboard: 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: {}
+      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"];
@@ -168,6 +173,15 @@ var require_settings = __commonJS({
     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) : [];
@@ -254,7 +268,7 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2, contentTypeUids2 = []) {
+    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");
@@ -305,9 +319,17 @@ var require_settings = __commonJS({
         }
         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, contentTypeUids2 = []) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null) {
       const types = typeMap(contentTypeUids2);
       const out = structuredClone(DEFAULTS2);
       if (!saved || typeof saved !== "object") return out;
@@ -343,6 +365,12 @@ var require_settings = __commonJS({
         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"];
@@ -361,6 +389,33 @@ var require_settings = __commonJS({
         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");
@@ -373,7 +428,7 @@ var require_settings = __commonJS({
       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, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
+    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 };
   }
 });
 
@@ -396,7 +451,7 @@ var require_hidden = __commonJS({
           skipped.push(uid);
           continue;
         }
-        if (!current) schema.attributes[name] = { type: "boolean", default: false, visible: false, configurable: false };
+        if (!current) schema.attributes[name] = { type: "boolean", default: false, configurable: false };
         added.push(uid);
       }
       return { added, skipped };
@@ -463,10 +518,411 @@ var require_hidden = __commonJS({
   }
 });
 
+// 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, TYPOLOGIES, DEFAULTS, catalog, validateSettings, mergeSaved, layer, overrides, validatePrefs, mergePrefs, 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) {
@@ -491,6 +947,7 @@ 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) {
@@ -584,6 +1041,8 @@ module.exports = {
       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"
     },
@@ -601,12 +1060,23 @@ module.exports = {
   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);
+    }
+  },
+  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 = () => {
@@ -614,18 +1084,33 @@ module.exports = {
       const code = strapi.plugin(PLUGIN).config("settings");
       project = null;
       if (code) try {
-        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi));
+        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.`);
       }
       return project;
     };
-    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi));
+    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));
+        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`);
         }
@@ -639,7 +1124,7 @@ module.exports = {
         return get();
       }
     };
-  } },
+  }, ...STRAPI5 && { history: historyService } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -666,11 +1151,16 @@ module.exports = {
           };
         }
         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,
           contentTypes: settings.contentTypes,
           hiddenAttribute: hidden,
+          fields: plugin.service("settings").fields(),
+          types,
+          history,
           editor: { ...settings.editor, enabled: settings.editor.enabled && !base.disabled, ...!hidden && { hiddenBlocks: "off" } }
         };
       }
@@ -702,7 +1192,9 @@ module.exports = {
           hiddenAttribute: hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")) || null,
           blockPreviewAvailable: strapi.plugin(PLUGIN).config("blockPreview") === true,
           defaults: DEFAULTS,
-          projectDefaults: strapi.plugin(PLUGIN).service("settings").projectDefaults()
+          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) {
@@ -725,7 +1217,8 @@ module.exports = {
         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"] } },
@@ -738,6 +1231,12 @@ module.exports = {
         name: "admin::hasPermissions",
         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`] } }] }
+    })) : []
   ] } }
 };