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

package/dist/server.cjs

@@ -144,21 +144,39 @@ 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,
+        // Page preview pane (Strapi 5): which toolbar controls show, in order, and the width menu's entries.
+        previewToolbar: ["modes", "history", "devices", "status", "actions"],
+        previewDevices: ["fit", "mobile", "tablet", "desktop"]
       },
       // Per content type (only the ones with a Dynamic Zone): { enabled: false } turns the plugin off there;
       // previewMode overrides editor.previewMode as the mode the edit view opens in. Absent means the global behaviour.
-      contentTypes: {}
+      contentTypes: {},
+      // Version history (Strapi 5, see README "Version history"): off until turned on. contentTypes: 'all' (every api:: type)
+      // or a list of uids. Snapshots are kept retentionDays and at most maxSnapshots per document; events eventDays; deleted
+      // documents stay in the trash trashDays (fixed per document when it is deleted).
+      history: { enabled: false, contentTypes: "all", retentionDays: 90, maxSnapshots: 100, eventDays: 365, trashDays: 90 }
     };
     var ICONS = ["text", "tag", "seo", "settings", "image", "link", "palette", "list", "globe", "info"];
     var SIDEBAR_POSITIONS = ["left", "right", "bottom"];
     var OPENS = ["modal", "drawer"];
     var LABEL = /^[^<>]{1,40}$/;
+    var TOOLBAR = ["modes", "history", "devices", "status", "actions"];
+    var DEVICE_NAMES = ["fit", "mobile", "tablet", "desktop"];
+    var previewToolbar = (value) => Array.isArray(value) && value.every((id) => TOOLBAR.includes(id)) && new Set(value).size === value.length;
+    var DEVICE_LABEL = /^[^<>]{1,24}$/;
+    var customDevice = (item) => item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).every((key) => ["label", "width"].includes(key)) && typeof item.label === "string" && DEVICE_LABEL.test(item.label.trim()) && Number.isInteger(item.width) && item.width >= 240 && item.width <= 3840;
+    var previewDevices = (value) => Array.isArray(value) && value.length >= 1 && value.length <= 8 && value.every((item) => DEVICE_NAMES.includes(item) || customDevice(item)) && new Set(value.map((item) => typeof item === "string" ? item : item.width)).size === value.length;
+    var cleanDevices = (value) => value.map((item) => typeof item === "string" ? item : { label: item.label.trim(), width: item.width });
     var sidebarItem = (item, attributes) => item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).every((key) => ["label", "icon", "open", "fields"].includes(key)) && typeof item.label === "string" && LABEL.test(item.label.trim()) && (item.icon === void 0 || item.icon === "" || ICONS.includes(item.icon)) && OPENS.includes(item.open) && Array.isArray(item.fields) && item.fields.length > 0 && item.fields.length <= 30 && item.fields.every((field) => typeof field === "string" && (!attributes || attributes.includes(field)));
     var TYPE_KEYS = {
       enabled: (value) => typeof value === "boolean",
       previewMode: (value) => PREVIEW_MODES.includes(value),
       sidebarPosition: (value) => SIDEBAR_POSITIONS.includes(value),
+      previewToolbar,
+      previewDevices,
       sidebar: (value, attributes) => Array.isArray(value) && value.length <= 12 && value.every((item) => sidebarItem(item, attributes))
     };
     var typeMap = (types) => Array.isArray(types) ? Object.fromEntries(types.map((uid) => [uid, null])) : types || {};
@@ -168,6 +186,16 @@ 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,
+      trashDays: days
+    };
     var TYPOLOGIES2 = ["hero", "text", "media", "listing", "cards", "cta", "form", "layout"];
     var TAG = /^[^<>\n]{1,24}$/;
     var cleanTags = (value) => Array.isArray(value) ? [...new Set(value.filter((tag) => typeof tag === "string" && TAG.test(tag.trim())).map((tag) => tag.trim()))].slice(0, 10) : [];
@@ -254,7 +282,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");
@@ -267,9 +295,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 === "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";
+        const valid = key === "initialState" ? INITIAL_STATES.includes(value) : key === "previewMode" ? PREVIEW_MODES.includes(value) : key === "hiddenBlocks" ? HIDDEN_MODES.includes(value) : key === "previewUrl" ? value === "" || typeof value === "string" && PREVIEW_URL.test(value) : key === "blockPreviewUrl" ? blockPreviewUrl(value) : key === "lazyFields" ? lazyFields(value) : key === "previewToolbar" ? previewToolbar(value) : key === "previewDevices" ? previewDevices(value) : typeof value === "boolean";
         if (!valid) fail2(`Invalid value for editor option "${key}"`);
-        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : key === "lazyFields" ? [...new Set(value)] : value;
+        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : key === "lazyFields" ? [...new Set(value)] : key === "previewDevices" ? cleanDevices(value) : value;
       }
       const components = input.components || {};
       if (typeof components !== "object" || Array.isArray(components)) fail2("components must be an object");
@@ -303,11 +331,19 @@ var require_settings = __commonJS({
           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);
+        if (Object.keys(entry).length) out.contentTypes[uid] = { ...structuredClone(entry), ...entry.previewDevices && { previewDevices: cleanDevices(entry.previewDevices) } };
+      }
+      const history = input.history || {};
+      if (typeof history !== "object" || Array.isArray(history)) fail2("history must be an object");
+      for (const [key, value] of Object.entries(history)) {
+        if (!(key in HISTORY_KEYS)) fail2(`Unknown history option "${key}"`);
+        if (!HISTORY_KEYS[key](value, historyTypes)) fail2(`Invalid value for history option "${key}"`);
+        out.history[key] = Array.isArray(value) ? [...new Set(value)] : value;
       }
+      if (out.history.eventDays < out.history.retentionDays) fail2("history.eventDays must be at least history.retentionDays");
       return out;
     }
-    function mergeSaved2(saved, componentUids2, contentTypeUids2 = []) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null) {
       const types = typeMap(contentTypeUids2);
       const out = structuredClone(DEFAULTS2);
       if (!saved || typeof saved !== "object") return out;
@@ -320,6 +356,8 @@ var require_settings = __commonJS({
         if (key === "hiddenBlocks" && !HIDDEN_MODES.includes(value)) continue;
         if (key === "previewUrl" && value && !PREVIEW_URL.test(value)) continue;
         if (key === "blockPreviewUrl" && !blockPreviewUrl(value)) continue;
+        if (key === "previewToolbar" && !previewToolbar(value)) continue;
+        if (key === "previewDevices" && !previewDevices(value)) continue;
         if (key === "lazyFields") {
           if (!Array.isArray(value)) continue;
           out.editor[key] = [...new Set(value.filter((uid) => lazyFields([uid])))].slice(0, 20);
@@ -343,24 +381,60 @@ 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"];
+    var UNSET_WHEN_EMPTY = ["previewUrl", "blockPreviewUrl"];
+    var withoutEmpty = (editor) => Object.fromEntries(Object.entries(editor).filter(([key, value]) => !(UNSET_WHEN_EMPTY.includes(key) && value === "")));
     function layer2(base, saved) {
       if (!base) return saved;
       const doc = saved && typeof saved === "object" ? saved : {};
-      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => [key, { ...base[key], ...doc[key] && typeof doc[key] === "object" ? doc[key] : {} }]));
+      const own = (key) => doc[key] && typeof doc[key] === "object" ? key === "editor" ? withoutEmpty(doc[key]) : doc[key] : {};
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => [key, { ...base[key], ...own(key) }]));
     }
     function overrides2(next, base) {
       if (!base) return next;
       return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => {
-        const entries = Object.entries(next[key] || {}).filter(([name, value]) => JSON.stringify(value) !== JSON.stringify(base[key]?.[name]));
+        const entries = Object.entries(next[key] || {}).filter(([name, value]) => JSON.stringify(value) !== JSON.stringify(base[key]?.[name]) && !(key === "editor" && UNSET_WHEN_EMPTY.includes(name) && value === ""));
         if (ENTRY_KEYS.includes(key)) {
           for (const uid of Object.keys(base[key] || {})) if (!(uid in (next[key] || {}))) entries.push([uid, {}]);
         }
         return [key, Object.fromEntries(entries)];
       }));
     }
+    var FIELD_TEXT = { label: 80, description: 300, placeholder: 120, help: 500 };
+    var LOCALE = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+    var plain = (value) => value && typeof value === "object" && !Array.isArray(value);
+    var fieldText = (value, max) => typeof value === "string" ? value.trim() !== "" && value.length <= max : plain(value) && Object.keys(value).length > 0 && Object.keys(value).length <= 30 && Object.entries(value).every(([locale, 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 +447,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 +470,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 +537,960 @@ 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/trash.js
+var require_trash = __commonJS({
+  "server/trash.js"(exports2, module2) {
+    "use strict";
+    var { AsyncLocalStorage } = require("node:async_hooks");
+    var { PLUGIN: PLUGIN2 } = require_settings();
+    var { kept, canonical, stable } = require_diff();
+    var history = () => require_history();
+    var TRASH_UID = `plugin::${PLUGIN2}.trash`;
+    var STATUSES = ["trashed", "restored"];
+    var DAY = 24 * 60 * 60 * 1e3;
+    var BATCH = 500;
+    var restoring = new AsyncLocalStorage();
+    var trashContentType2 = { schema: {
+      kind: "collectionType",
+      collectionName: "blockscene_trash",
+      info: { singularName: "trash", pluralName: "trashes", displayName: "Blockscene trash" },
+      options: { draftAndPublish: false },
+      pluginOptions: { "content-manager": { visible: false }, "content-type-builder": { visible: false }, i18n: { localized: false } },
+      attributes: {
+        contentType: { type: "string", required: true },
+        relatedDocumentId: { type: "string", required: true },
+        // The document's main field (Content Manager setting) at delete time, for the list and the search.
+        title: { type: "string" },
+        // The locales the delete removed ([null] for a type without i18n).
+        locales: { type: "json" },
+        // [{ locale, status: 'draft' | 'published' | null (no Draft & Publish), snapshot }]: canonical snapshots (server/diff.js).
+        entries: { type: "json" },
+        // Links other documents' and blocks' unidirectional relations had to the deleted rows (see `incomingRows`).
+        incoming: { type: "json" },
+        actor: { type: "string", required: true },
+        actorName: { type: "string" },
+        deletedAt: { type: "datetime", required: true },
+        // deletedAt + trash retention at delete time; the nightly purge deletes the row after it.
+        expiresAt: { type: "datetime", required: true },
+        status: { type: "enumeration", enum: STATUSES, required: true, default: "trashed" },
+        restoredAs: { type: "string" },
+        restoredAt: { type: "datetime" },
+        size: { type: "integer" }
+      },
+      indexes: [{ name: "blockscene_trash_list", columns: ["status", "content_type", "deleted_at"] }, { name: "blockscene_trash_expiry", columns: ["expires_at"] }]
+    } };
+    var expiresAt = (deletedAt, days) => new Date(new Date(deletedAt).getTime() + days * DAY);
+    var isObject = (value) => value && typeof value === "object" && !Array.isArray(value);
+    var blank = (value) => value === null || value === void 0 || value === "" || Array.isArray(value) && !value.length;
+    var toMany = (attr) => /ToMany$|^manyWay$/.test(String(attr?.relation || ""));
+    var toOne = (attr) => ["oneToOne", "manyToOne"].includes(attr?.relation);
+    var uniqueFields = (schema) => Object.entries(schema?.attributes || {}).filter(([name, attr]) => kept(name, attr) && (attr.unique === true || attr.type === "uid")).map(([name]) => name);
+    function chooseEntries(entries) {
+      const chosen = /* @__PURE__ */ new Map();
+      for (const entry of Array.isArray(entries) ? entries : []) {
+        const locale = entry?.locale ?? null, current = chosen.get(locale);
+        if (!current || current.status === "published" && entry.status !== "published") chosen.set(locale, entry);
+      }
+      return chosen;
+    }
+    function restorePayload(snapshot, schema, schemaOf, { media = /* @__PURE__ */ new Set(), relation = () => false } = {}) {
+      const report = { removed: [], media: 0, relations: 0, blocks: 0 };
+      const ref = (item) => ({ documentId: item.documentId, ...item.locale && { locale: item.locale } });
+      const build = (data, schema2, top, depth) => {
+        const out = {};
+        if (!isObject(data) || depth > 20) return out;
+        for (const [name, value] of Object.entries(data)) {
+          if (name === "__component") continue;
+          const attr = schema2?.attributes?.[name];
+          const drop = () => {
+            if (top) report.removed.push(name);
+          };
+          if (!kept(name, attr)) {
+            drop();
+            continue;
+          }
+          const list = Array.isArray(value) ? value : value == null ? [] : [value];
+          if (attr.type === "relation") {
+            const refs = list.filter((item) => isObject(item) && typeof item.documentId === "string");
+            const found = refs.filter((item) => relation(attr.target, item));
+            report.relations += refs.length - found.length;
+            out[name] = toMany(attr) ? found.map(ref) : found[0] ? ref(found[0]) : null;
+          } else if (attr.type === "media") {
+            const ids = list.filter(Number.isInteger), found = ids.filter((id) => media.has(id));
+            report.media += ids.length - found.length;
+            out[name] = attr.multiple ? found : found[0] ?? null;
+          } else if (attr.type === "component") {
+            const child = schemaOf(attr.component);
+            if (!child) {
+              drop();
+              continue;
+            }
+            out[name] = attr.repeatable ? list.filter(isObject).map((item) => build(item, child, false, depth + 1)) : isObject(value) ? build(value, child, false, depth + 1) : null;
+          } else if (attr.type === "dynamiczone") {
+            const rows = list.filter((row) => isObject(row) && typeof row.__component === "string");
+            const allowed = rows.filter((row) => (attr.components || []).includes(row.__component) && schemaOf(row.__component));
+            report.blocks += rows.length - allowed.length;
+            out[name] = allowed.map((row) => ({ __component: row.__component, ...build(row, schemaOf(row.__component), false, depth + 1) }));
+          } else if (attr.type === "enumeration" && !(attr.enum || []).includes(value)) drop();
+          else out[name] = value;
+        }
+        return out;
+      };
+      return { data: build(snapshot, schema, true, 0), report };
+    }
+    function planRestore(entries, { schema, schemaOf, locales = null, defaultLocale = null, existing = null, singleTaken = false, taken = () => false, media, relation }) {
+      const blocking = [], warnings = [], steps = [];
+      const published = (Array.isArray(entries) ? entries : []).filter((entry) => entry?.status === "published").map((entry) => entry.locale ?? null);
+      if (published.length) warnings.push({ code: "published", locales: published });
+      if (singleTaken && !existing) blocking.push({ code: "singleExists" });
+      for (const [locale, entry] of chooseEntries(entries)) {
+        if (locales && !locales.includes(locale)) {
+          warnings.push({ code: "localeRemoved", locale });
+          continue;
+        }
+        if (existing?.includes(locale)) {
+          blocking.push({ code: "localeExists", locale });
+          continue;
+        }
+        const { data, report } = restorePayload(entry.snapshot, schema, schemaOf, { media, relation });
+        for (const field of uniqueFields(schema)) if (!blank(data[field]) && taken(field, locale, data[field])) blocking.push({ code: "unique", locale, field, value: String(data[field]).slice(0, 100) });
+        const required = Object.entries(schema?.attributes || {}).filter(([name, attr]) => attr?.required && kept(name, attr) && blank(data[name])).map(([name]) => name);
+        if (required.length) warnings.push({ code: "required", locale, fields: required });
+        if (report.removed.length) warnings.push({ code: "fieldsRemoved", locale, fields: report.removed });
+        for (const code of ["media", "relations", "blocks"]) if (report[code]) warnings.push({ code, locale, count: report[code] });
+        steps.push({ locale, data });
+      }
+      if (!steps.length && !blocking.length) blocking.push({ code: "nothing" });
+      steps.sort((a, b) => (b.locale === defaultLocale) - (a.locale === defaultLocale));
+      return { blocking, warnings, steps };
+    }
+    var incomingSources = (uid, models) => models.flatMap((model) => Object.entries(model.attributes || {}).filter(([, attr]) => attr?.type === "relation" && attr.target === uid && !attr.inversedBy && !attr.mappedBy && attr.joinTable).map(([field, attr]) => ({ owner: model.uid, kind: model.kind, field, joinTable: attr.joinTable, single: toOne(attr) })));
+    function incomingRows(source, links, deleted, owners = /* @__PURE__ */ new Map()) {
+      const { joinColumn, inverseJoinColumn, orderColumnName } = source.joinTable;
+      return links.filter((link) => deleted.has(link[inverseJoinColumn.name]) && !(source.kind === "contentType" && source.owner === source.target && deleted.has(link[joinColumn.name]))).map((link) => {
+        const target = deleted.get(link[inverseJoinColumn.name]), owner = owners.get(link[joinColumn.name]);
+        return {
+          owner: source.owner,
+          kind: source.kind,
+          field: source.field,
+          ownerId: link[joinColumn.name],
+          ...source.kind === "contentType" && { ownerDocumentId: owner?.documentId ?? null, ownerLocale: owner?.locale ?? null },
+          locale: target.locale ?? null,
+          published: Boolean(target.published),
+          order: orderColumnName ? link[orderColumnName] ?? null : null
+        };
+      });
+    }
+    function previewOf(snapshot, schema, schemaOf) {
+      const fields = [], blocks = [];
+      const text = (value) => {
+        const s = typeof value === "string" ? value : stable(value);
+        return s.length > 200 ? `${s.slice(0, 199)}\u2026` : s;
+      };
+      for (const [name, value] of Object.entries(isObject(snapshot) ? snapshot : {})) {
+        const attr = schema?.attributes?.[name];
+        if (attr?.type === "dynamiczone") {
+          for (const row of Array.isArray(value) ? value : []) blocks.push({ zone: name, uid: row?.__component, name: schemaOf(row?.__component)?.info?.displayName || row?.__component });
+          continue;
+        }
+        const count = Array.isArray(value) ? value.length : 1;
+        fields.push({ name, type: attr?.type || "removed", ...["relation", "media", "component"].includes(attr?.type) ? { count } : { value: text(value) } });
+      }
+      return { fields, blocks };
+    }
+    function trashService2({ strapi }) {
+      const events = () => strapi.plugin(PLUGIN2).service("history");
+      const rows = () => strapi.db.query(TRASH_UID);
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const localized = (uid) => Boolean(schemaOf(uid)?.pluginOptions?.i18n?.localized);
+      const draftAndPublish = (uid) => schemaOf(uid)?.options?.draftAndPublish === true;
+      const models = () => [...Object.values(strapi.contentTypes || {}).map((model) => ({ uid: model.uid, kind: "contentType" })), ...Object.values(strapi.components || {}).map((model) => ({ uid: model.uid, kind: "component" }))].map((model) => ({ ...model, attributes: strapi.db.metadata.get(model.uid)?.attributes })).filter((model) => model.attributes);
+      const table = (trx, name) => strapi.db.getConnection(name).transacting(trx);
+      const lookups = async (uid, snapshots) => {
+        const ids = /* @__PURE__ */ new Set(), refs = [];
+        for (const snapshot of snapshots) {
+          const found = history().refsOf(snapshot, schemaOf(uid), schemaOf);
+          found.media.forEach((id) => ids.add(id));
+          refs.push(...found.relations);
+        }
+        const files = ids.size ? await strapi.db.query("plugin::upload.file").findMany({ select: ["id"], where: { id: { $in: [...ids] } } }) : [];
+        const present = /* @__PURE__ */ new Set();
+        for (const target of [...new Set(refs.map((ref) => ref.target))]) {
+          if (!strapi.contentTypes?.[target]) continue;
+          const found = await strapi.db.query(target).findMany({ select: ["documentId", "locale"], where: {
+            documentId: { $in: [...new Set(refs.filter((ref) => ref.target === target).map((ref) => ref.documentId))] },
+            ...draftAndPublish(target) && { publishedAt: { $null: true } }
+          } });
+          for (const row of found) {
+            present.add(`${target}|${row.documentId}|${row.locale || ""}`);
+            present.add(`${target}|${row.documentId}|*`);
+          }
+        }
+        return { media: new Set(files.map((file) => file.id)), relation: (target, ref) => present.has(`${target}|${ref.documentId}|${localized(target) && ref.locale ? ref.locale : "*"}`) };
+      };
+      const resolveIncoming = async (uid, incoming, locales, trx) => {
+        const out = { links: [], gone: 0, published: 0, replaced: 0 };
+        for (const link of Array.isArray(incoming) ? incoming : []) {
+          if (!locales.includes(link.locale)) continue;
+          if (link.published) {
+            out.published++;
+            continue;
+          }
+          const attr = strapi.db.metadata.get(link.owner)?.attributes?.[link.field];
+          if (!attr?.joinTable || attr.target !== uid) {
+            out.gone++;
+            continue;
+          }
+          let ownerId = null;
+          if (link.kind === "component") ownerId = (await strapi.db.query(link.owner).findOne({ select: ["id"], where: { id: link.ownerId } }))?.id ?? null;
+          else if (strapi.contentTypes?.[link.owner] && link.ownerDocumentId) ownerId = (await strapi.db.query(link.owner).findOne({ select: ["id"], where: {
+            documentId: link.ownerDocumentId,
+            ...localized(link.owner) && { locale: link.ownerLocale },
+            ...draftAndPublish(link.owner) && { publishedAt: { $null: true } }
+          } }))?.id ?? null;
+          if (!ownerId) {
+            out.gone++;
+            continue;
+          }
+          const { joinTable } = attr;
+          if (toOne(attr) && await table(trx, joinTable.name).where(joinTable.joinColumn.name, ownerId).first()) {
+            out.replaced++;
+            continue;
+          }
+          out.links.push({ ...link, ownerRowId: ownerId, joinTable });
+        }
+        return out;
+      };
+      const self = {
+        TRASH_UID,
+        // Before the delete, in its transaction: the links other documents and blocks have to the rows about to be deleted.
+        async incoming(uid, deleted) {
+          if (!deleted.size) return [];
+          return strapi.db.transaction(async ({ trx }) => {
+            const out = [];
+            for (const source of incomingSources(uid, models())) {
+              const links = await table(trx, source.joinTable.name).select("*").whereIn(source.joinTable.inverseJoinColumn.name, [...deleted.keys()]);
+              if (!links.length) continue;
+              const owners = source.kind === "contentType" && strapi.contentTypes?.[source.owner] ? new Map((await strapi.db.query(source.owner).findMany({
+                select: ["id", "documentId", "locale"],
+                where: { id: { $in: [...new Set(links.map((link) => link[source.joinTable.joinColumn.name]))] } }
+              })).map((row) => [row.id, row])) : /* @__PURE__ */ new Map();
+              out.push(...incomingRows({ ...source, target: uid }, links, deleted, owners));
+            }
+            return out;
+          });
+        },
+        // After the delete, in its transaction: the trash row. drafts/published: the stored rows read before the delete.
+        async record({ uid, documentId, locales, drafts, published, incoming, actor, days }) {
+          const dp = draftAndPublish(uid);
+          const entries = [...drafts.map((row) => [row, dp ? "draft" : null]), ...published.map((row) => [row, "published"])].map(([row, status]) => ({ locale: row.locale ?? null, status, snapshot: canonical(row, schemaOf(uid), schemaOf) }));
+          const main = await events().mainField(uid);
+          const first = chooseEntries(entries);
+          const source = first.get(await events().scope(uid).then((list) => list?.[0] ?? null).catch(() => null)) || [...first.values()][0];
+          const title = main && source?.snapshot?.[main] != null ? String(source.snapshot[main]).slice(0, 255) : null;
+          const deletedAt = /* @__PURE__ */ new Date();
+          return rows().create({ data: {
+            contentType: uid,
+            relatedDocumentId: documentId,
+            title,
+            locales: locales || [...new Set(entries.map((entry) => entry.locale))],
+            entries,
+            incoming,
+            ...actor,
+            deletedAt,
+            expiresAt: expiresAt(deletedAt, days),
+            status: "trashed",
+            size: Buffer.byteLength(stable({ entries, incoming }))
+          } });
+        },
+        // One page of trash rows, without their snapshots. `types`: the content types the user may read.
+        async list({ contentType, status = "trashed", page = 1, pageSize = 20, types }) {
+          const where = { status, contentType: contentType ? contentType : { $in: types } };
+          if (contentType && !types.includes(contentType)) return { results: [], pagination: { page, pageSize, total: 0, pageCount: 0 } };
+          const [results, total] = await Promise.all([
+            rows().findMany({
+              select: ["id", "contentType", "relatedDocumentId", "title", "locales", "actor", "actorName", "deletedAt", "expiresAt", "status", "restoredAs", "restoredAt"],
+              where,
+              orderBy: [{ deletedAt: "desc" }, { id: "desc" }],
+              offset: (page - 1) * pageSize,
+              limit: pageSize
+            }),
+            rows().count({ where })
+          ]);
+          return { results, pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) } };
+        },
+        async find(id) {
+          return rows().findOne({ where: { id } });
+        },
+        // One row for the preview: fields and blocks of each entry, and how many links it held.
+        preview(row) {
+          const schema = schemaOf(row.contentType);
+          const { entries, incoming, ...meta } = row;
+          return {
+            ...meta,
+            incoming: (incoming || []).length,
+            entries: (entries || []).map((entry) => ({ locale: entry.locale ?? null, status: entry.status ?? null, ...previewOf(entry.snapshot, schema, schemaOf) }))
+          };
+        },
+        // The pre-check: every lookup a restore needs, then planRestore. Read-only; the restore runs it again in its transaction.
+        async plan(row) {
+          const uid = row.contentType, schema = schemaOf(uid);
+          if (!schema || !strapi.contentTypes?.[uid]) return { blocking: [{ code: "typeGone" }], warnings: [], steps: [], incoming: { links: [], gone: 0, published: 0, replaced: 0 } };
+          const i18n = localized(uid);
+          const locales = i18n ? (await strapi.plugin("i18n").service("locales").find()).map((locale) => locale.code) : null;
+          const defaultLocale = i18n ? await strapi.plugin("i18n").service("locales").getDefaultLocale() : null;
+          const current = await strapi.db.query(uid).findMany({ select: ["locale"], where: { documentId: row.relatedDocumentId } });
+          const existing = current.length ? [...new Set(current.map((entry) => i18n ? entry.locale : null))] : null;
+          const singleTaken = schema.kind === "singleType" && !existing && Boolean(await strapi.db.query(uid).findOne({ select: ["id"] }));
+          const chosen = [...chooseEntries(row.entries).values()];
+          const { media, relation } = await lookups(uid, chosen.map((entry) => entry.snapshot));
+          const taken = /* @__PURE__ */ new Set();
+          for (const entry of chosen) for (const field of uniqueFields(schema)) {
+            const value = entry.snapshot?.[field];
+            if (blank(value) || typeof value === "object") continue;
+            const other = await strapi.db.query(uid).findOne({ select: ["id"], where: { [field]: value, ...i18n && { locale: entry.locale }, ...existing && { documentId: { $ne: row.relatedDocumentId } } } });
+            if (other) taken.add(stable([field, entry.locale ?? null, value]));
+          }
+          const plan = planRestore(row.entries, { schema, schemaOf, locales, defaultLocale, existing, singleTaken, media, relation, taken: (field, locale, value) => taken.has(stable([field, locale ?? null, value])) });
+          const incoming = await strapi.db.transaction(({ trx }) => resolveIncoming(uid, row.incoming, plan.steps.map((step) => step.locale), trx));
+          return { ...plan, documentId: existing ? row.relatedDocumentId : null, incoming };
+        },
+        // What the pre-check endpoint returns: the plan without the data it would write.
+        async check(row) {
+          if (row.status !== "trashed") return { status: row.status, restoredAs: row.restoredAs, blocking: [{ code: "restored" }], warnings: [] };
+          const { steps, incoming: { links, ...incoming }, ...plan } = await self.plan(row);
+          return { ...plan, locales: steps.map((step) => step.locale), incoming: { ...incoming, reconnect: links.length } };
+        },
+        // Restore as a draft, in one transaction: claim the row (a second restore of the same row, concurrent or later, gets
+        // `already` with the first one's document), check again, recreate (default locale first, the others under the same
+        // documentId), put the links back, record `restore` events. A blocking problem throws `conflict` and nothing is written.
+        async restore(id, { actor, userId }) {
+          return restoring.run(true, () => strapi.db.transaction(async ({ trx }) => {
+            const claimed = await rows().updateMany({ where: { id, status: "trashed" }, data: { status: "restored", restoredAt: /* @__PURE__ */ new Date() } });
+            const row = await rows().findOne({ where: { id } });
+            if (!row) return null;
+            if (!claimed?.count) return { already: true, documentId: row.restoredAs || null };
+            const plan = await self.plan(row);
+            if (plan.blocking.length) {
+              const error = new Error("conflict");
+              error.conflict = { blocking: plan.blocking, warnings: plan.warnings };
+              throw error;
+            }
+            const uid = row.contentType, documents = strapi.documents(uid);
+            const creator = userId ? { createdBy: userId, updatedBy: userId } : {};
+            let documentId = plan.documentId;
+            for (const { locale, data } of plan.steps) {
+              const params = { ...locale && { locale }, data: { ...data, ...creator } };
+              if (documentId) await documents.update({ documentId, ...params });
+              else documentId = (await documents.create(params)).documentId;
+            }
+            const restored = await events().rows(uid, documentId, localized(uid) ? plan.steps.map((step) => step.locale) : null);
+            const rowOf = new Map(restored.map((entry) => [entry.locale ?? null, entry]));
+            for (const link of plan.incoming.links) {
+              const target = rowOf.get(link.locale);
+              if (!target) continue;
+              const { joinColumn, inverseJoinColumn, orderColumnName } = link.joinTable;
+              await table(trx, link.joinTable.name).insert({ [joinColumn.name]: link.ownerRowId, [inverseJoinColumn.name]: target.id, ...orderColumnName && link.order != null && { [orderColumnName]: link.order } });
+            }
+            for (const entry of restored) await events().record({ uid, documentId, locale: entry.locale ?? null, action: "restore", entry, actor, extra: { restoredFrom: row.relatedDocumentId, trash: row.id } });
+            await rows().update({ where: { id }, data: { restoredAs: documentId } });
+            const { links, ...incoming } = plan.incoming;
+            return { documentId, locales: plan.steps.map((step) => step.locale), warnings: plan.warnings, incoming: { ...incoming, reconnected: links.length } };
+          }));
+        },
+        // Delete forever (one row), recorded as a `purge` event. Never touches media files.
+        async remove(row, actor) {
+          return strapi.db.transaction(async () => {
+            const { count } = await rows().deleteMany({ where: { id: row.id } });
+            if (count) await events().record({ uid: row.contentType, documentId: row.relatedDocumentId, action: "purge", actor, extra: { trash: row.id, title: row.title } });
+            return count;
+          });
+        },
+        // Nightly, in batches, idempotent: rows past expiresAt are deleted (restored ones too). Never touches media files.
+        async purge(now = Date.now()) {
+          let count = 0;
+          for (; ; ) {
+            const ids = (await rows().findMany({ select: ["id"], where: { expiresAt: { $lt: new Date(now) } }, orderBy: { id: "asc" }, limit: BATCH })).map((row) => row.id);
+            if (ids.length) await rows().deleteMany({ where: { id: { $in: ids } } });
+            count += ids.length;
+            if (ids.length < BATCH) return count;
+          }
+        }
+      };
+      return self;
+    }
+    var ID = /^[1-9]\d{0,15}$/;
+    var API_UID = /^api::[\w-]+\.[\w-]+$/;
+    var int = (value, fallback, max) => {
+      if (value === void 0 || value === "") return fallback;
+      const n = Number(value);
+      return Number.isInteger(n) && n >= 1 && n <= max ? n : NaN;
+    };
+    var trashController2 = ({ strapi }) => {
+      const service = () => strapi.plugin(PLUGIN2).service("trash");
+      const { can, readableTypes, actorOf } = history();
+      const load = async (ctx, action = "read") => {
+        if (!ID.test(String(ctx.params?.id || ""))) {
+          ctx.badRequest("Invalid trash entry");
+          return null;
+        }
+        const row = await service().find(Number(ctx.params.id));
+        if (!row || !can(strapi, ctx, row.contentType, "read") || action !== "read" && !can(strapi, ctx, row.contentType, action)) {
+          ctx.notFound();
+          return null;
+        }
+        return row;
+      };
+      return {
+        async list(ctx) {
+          const { contentType = "", status = "trashed" } = ctx.query || {};
+          const page = int(ctx.query?.page, 1, 1e4), pageSize = int(ctx.query?.pageSize, 20, 100);
+          if (typeof contentType !== "string" || contentType && !API_UID.test(contentType) || !STATUSES.includes(status) || Number.isNaN(page) || Number.isNaN(pageSize)) return ctx.badRequest("Invalid filters");
+          const types = readableTypes(strapi, ctx);
+          ctx.body = {
+            ...await service().list({ contentType, status, page, pageSize, types }),
+            types: types.map((uid) => ({ uid, displayName: strapi.contentTypes[uid].info?.displayName || uid, kind: strapi.contentTypes[uid].kind, localized: Boolean(strapi.contentTypes[uid].pluginOptions?.i18n?.localized) }))
+          };
+        },
+        async find(ctx) {
+          const row = await load(ctx);
+          if (row) ctx.body = service().preview(row);
+        },
+        async check(ctx) {
+          const row = await load(ctx, "create");
+          if (row) ctx.body = await service().check(row);
+        },
+        async restore(ctx) {
+          const row = await load(ctx, "create");
+          if (!row) return;
+          try {
+            const result = await service().restore(row.id, { actor: actorOf(strapi), userId: ctx.state?.user?.id });
+            if (!result) return ctx.notFound();
+            ctx.body = result;
+          } catch (error) {
+            if (!error?.conflict) throw error;
+            ctx.status = 409;
+            ctx.body = { data: null, error: { status: 409, name: "ConflictError", message: "The document cannot be restored as it is: nothing was written.", details: error.conflict } };
+          }
+        },
+        async remove(ctx) {
+          const row = await load(ctx, "delete");
+          if (!row) return;
+          ctx.body = { deleted: await service().remove(row, actorOf(strapi)) };
+        }
+      };
+    };
+    module2.exports = { TRASH_UID, STATUSES, restoring, trashContentType: trashContentType2, expiresAt, uniqueFields, chooseEntries, restorePayload, planRestore, incomingSources, incomingRows, previewOf, trashService: trashService2, trashController: trashController2 };
+  }
+});
+
+// server/history.js
+var require_history = __commonJS({
+  "server/history.js"(exports2, module2) {
+    "use strict";
+    var { createHash } = require("node:crypto");
+    var { PLUGIN: PLUGIN2 } = require_settings();
+    var { snapshotPopulate, canonical, stable, summarize } = require_diff();
+    var { TRASH_UID, restoring } = require_trash();
+    var EVENT_UID = `plugin::${PLUGIN2}.event`;
+    var ACTIONS = ["create", "update", "publish", "unpublish", "discard", "delete", "restore", "purge"];
+    var CAPTURED = { create: "create", clone: "create", update: "update", publish: "publish", unpublish: "unpublish", discardDraft: "discard", delete: "delete" };
+    var CRON2 = "blocksceneHistoryPurge";
+    var BATCH = 500;
+    var DAY = 24 * 60 * 60 * 1e3;
+    var LIST_LIMIT = 100;
+    var ACTORS_LIMIT = 500;
+    var SEARCH_LIMIT = 200;
+    var eventContentType2 = { schema: {
+      kind: "collectionType",
+      collectionName: "blockscene_events",
+      info: { singularName: "event", pluralName: "events", displayName: "Blockscene event" },
+      options: { draftAndPublish: false },
+      pluginOptions: { "content-manager": { visible: false }, "content-type-builder": { visible: false }, i18n: { localized: false } },
+      attributes: {
+        contentType: { type: "string", required: true },
+        relatedDocumentId: { type: "string", required: true },
+        locale: { type: "string" },
+        action: { type: "enumeration", enum: ACTIONS, required: true },
+        // 'admin:<id>', 'token:<id>', 'user:<id>' (Users & Permissions) or 'system'; the name as it was at that moment.
+        actor: { type: "string", required: true },
+        actorName: { type: "string" },
+        at: { type: "datetime", required: true },
+        // { fields: [names], blocks: { added, removed, changed }, initial? } vs the previous snapshot; { missing: true } when the capture failed;
+        // restore: + { restoredFrom, trash }; purge: { trash, title }.
+        summary: { type: "json" },
+        // Null when identical to the previous snapshot of the same locale (same hash) or purged.
+        snapshot: { type: "json" },
+        hash: { type: "string" },
+        size: { type: "integer" }
+      },
+      indexes: [{ name: "blockscene_events_lookup", columns: ["content_type", "related_document_id", "locale", "at"] }]
+    } };
+    var fail2 = (message, Kind = "ApplicationError") => {
+      let E;
+      try {
+        E = require("@strapi/utils").errors[Kind];
+      } catch {
+        E = class extends Error {
+          constructor(m) {
+            super(m);
+            this.name = Kind;
+          }
+        };
+      }
+      throw new E(message);
+    };
+    var hashOf = (text) => createHash("sha256").update(text).digest("hex");
+    var covers2 = (history, uid) => Boolean(history?.enabled) && uid.startsWith("api::") && (history.contentTypes === "all" || Array.isArray(history.contentTypes) && history.contentTypes.includes(uid));
+    var retention = ({ retentionDays, eventDays }, now = Date.now()) => ({ snapshotsBefore: new Date(now - retentionDays * DAY), eventsBefore: new Date(now - eventDays * DAY) });
+    function actorOf(strapi) {
+      let ctx;
+      try {
+        ctx = strapi.requestContext?.get?.();
+      } catch {
+        ctx = null;
+      }
+      const strategy = ctx?.state?.auth?.strategy?.name, user = ctx?.state?.user, token = ctx?.state?.auth?.credentials;
+      const name = (value) => String(value || "").slice(0, 255);
+      if (strategy === "admin" && user?.id) return { actor: `admin:${user.id}`, actorName: name([user.firstname, user.lastname].filter(Boolean).join(" ") || user.username || user.email) };
+      if (strategy === "api-token" && token?.id) return { actor: `token:${token.id}`, actorName: name(token.name) };
+      if (user?.id) return { actor: `user:${user.id}`, actorName: name(user.username || user.email) };
+      return { actor: "system", actorName: "" };
+    }
+    function refsOf(snapshot, schema, schemaOf) {
+      const media = /* @__PURE__ */ new Set(), relations = [];
+      const walk = (data, schema2, depth) => {
+        if (!data || typeof data !== "object" || depth > 20) return;
+        for (const [name, attr] of Object.entries(schema2?.attributes || {})) {
+          const value = data[name];
+          if (value == null) continue;
+          const list = Array.isArray(value) ? value : [value];
+          if (attr.type === "media") list.forEach((id) => Number.isInteger(id) && media.add(id));
+          else if (attr.type === "relation" && attr.target) list.forEach((ref) => ref?.documentId && relations.push({ target: attr.target, ...ref }));
+          else if (attr.type === "component") list.forEach((item) => walk(item, schemaOf(attr.component), depth + 1));
+          else if (attr.type === "dynamiczone") list.forEach((row) => walk(row, schemaOf(row?.__component), depth + 1));
+        }
+      };
+      walk(snapshot, schema, 0);
+      return { media: [...media], relations };
+    }
+    function historyService2({ strapi }) {
+      const plugin = () => strapi.plugin(PLUGIN2);
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const localized = (uid) => Boolean(schemaOf(uid)?.pluginOptions?.i18n?.localized);
+      const draftAndPublish = (uid) => schemaOf(uid)?.options?.draftAndPublish === true;
+      const events = () => strapi.db.query(EVENT_UID);
+      const actors = async () => {
+        const meta = strapi.db.metadata.get(EVENT_UID);
+        const column = (name) => meta.attributes[name].columnName || name;
+        return strapi.db.connection(meta.tableName).select({ actor: column("actor") }).max({ actorName: column("actorName") }).groupBy(column("actor")).orderBy(column("actor")).limit(ACTORS_LIMIT);
+      };
+      const scope = async (uid, locale) => {
+        if (!localized(uid)) return [null];
+        if (locale === "*") return null;
+        if (Array.isArray(locale) && locale.length) return locale;
+        if (typeof locale === "string" && locale) return [locale];
+        return [await strapi.plugin("i18n").service("locales").getDefaultLocale()];
+      };
+      const rows = async (uid, documentId, locales, published = false) => !documentId ? [] : strapi.db.query(uid).findMany({
+        where: {
+          documentId,
+          ...locales && localized(uid) && { locale: { $in: locales } },
+          ...draftAndPublish(uid) && { publishedAt: published ? { $notNull: true } : { $null: true } }
+        },
+        populate: snapshotPopulate(uid, schemaOf)
+      });
+      const self = {
+        EVENT_UID,
+        async config() {
+          return (await plugin().service("settings").get()).history;
+        },
+        covers: covers2,
+        // One event. The snapshot is stored unless identical to the latest stored one of the same document and locale.
+        async record({ uid, documentId, locale = null, action, entry, actor, missing = false, extra = null }) {
+          let summary = missing ? { missing: true } : null, snapshot = null, hash = null, size = 0;
+          if (entry) {
+            const content = canonical(entry, schemaOf(uid), schemaOf);
+            const text = stable(content);
+            hash = hashOf(text);
+            const previous = await events().findOne({ select: ["hash", "snapshot"], where: { contentType: uid, relatedDocumentId: documentId, locale, size: { $gt: 0 } }, orderBy: [{ at: "desc" }, { id: "desc" }] });
+            summary = summarize(previous?.snapshot || null, content, schemaOf(uid));
+            if (previous?.hash !== hash) {
+              snapshot = content;
+              size = Buffer.byteLength(text);
+            }
+          }
+          if (extra) summary = { ...summary, ...extra };
+          return events().create({ data: { contentType: uid, relatedDocumentId: documentId, locale, action, ...actor, at: /* @__PURE__ */ new Date(), summary, snapshot, hash, size } });
+        },
+        // After a save or publish: one event per affected entry (drafts, or the published versions after a publish).
+        async captureSave({ uid, action, documentId, locales, published, actor }) {
+          if (!documentId) return;
+          for (const entry of await rows(uid, documentId, locales, published)) await self.record({ uid, documentId, locale: entry.locale ?? null, action, entry, actor });
+        },
+        scope,
+        rows,
+        // The Content Manager's main field of a content type when it is a plain value (what list views show), else null.
+        async mainField(uid) {
+          let name = null;
+          try {
+            name = (await strapi.plugin("content-manager").service("content-types").findConfiguration(strapi.contentTypes[uid]))?.settings?.mainField;
+          } catch {
+            name = null;
+          }
+          return name && name !== "id" && schemaOf(uid)?.attributes?.[name] && !["relation", "media", "component", "dynamiczone", "password", "json", "blocks"].includes(schemaOf(uid).attributes[name].type) ? name : null;
+        },
+        // Latest events of one document and locale, newest first; `stored`: its snapshot (or an identical one) can be loaded.
+        async list({ uid, documentId, locale }) {
+          const where = { contentType: uid, relatedDocumentId: documentId, locale: locale || null };
+          const [list, kept] = await Promise.all([
+            events().findMany({ select: ["id", "action", "actor", "actorName", "at", "summary", "hash", "size"], where, orderBy: [{ at: "desc" }, { id: "desc" }], limit: LIST_LIMIT }),
+            events().findMany({ select: ["hash"], where: { ...where, size: { $gt: 0 } } })
+          ]);
+          const hashes = new Set(kept.map((row) => row.hash));
+          return list.map(({ hash, size, ...event }) => ({ ...event, stored: Boolean(hash && hashes.has(hash)) }));
+        },
+        // One event with its snapshot (from an identical event when this one was deduplicated) and what loading it needs:
+        // the media files and relation targets that still exist (relation labels from the Content Manager's main field).
+        async find(id) {
+          const event = await events().findOne({ where: { id } });
+          if (!event) return null;
+          const { snapshot: own, ...meta } = event;
+          const snapshot = own || event.hash && (await events().findOne({ select: ["snapshot"], where: { contentType: event.contentType, relatedDocumentId: event.relatedDocumentId, locale: event.locale, hash: event.hash, size: { $gt: 0 } } }))?.snapshot || null;
+          if (!snapshot) return { event: meta, snapshot: null, media: {}, relations: {} };
+          const refs = refsOf(snapshot, schemaOf(event.contentType), schemaOf);
+          const files = refs.media.length ? await strapi.db.query("plugin::upload.file").findMany({ where: { id: { $in: refs.media } } }) : [];
+          const relations = {};
+          for (const target of [...new Set(refs.relations.map((ref) => ref.target))]) {
+            if (!strapi.contentTypes?.[target]) continue;
+            const mainField = await self.mainField(target), scalar = Boolean(mainField);
+            const found = await strapi.db.query(target).findMany({
+              select: ["id", "documentId", "locale", ...scalar ? [mainField] : []],
+              where: { documentId: { $in: [...new Set(refs.relations.filter((ref) => ref.target === target).map((ref) => ref.documentId))] }, ...draftAndPublish(target) && { publishedAt: { $null: true } } }
+            });
+            relations[target] = found.map((row) => ({ id: row.id, documentId: row.documentId, locale: row.locale || null, label: scalar && row[mainField] != null ? String(row[mainField]) : void 0, mainField: scalar ? mainField : void 0 }));
+          }
+          return { event: meta, snapshot, media: Object.fromEntries(files.map((file) => [file.id, file])), relations };
+        },
+        // Content activity: one page of events (no snapshots), newest first, with each document's title and whether it still
+        // exists (the list links to it). `types`: the content types the user may read. `q`: documents whose main field
+        // contains it now, or whose trash entry's title does (at most SEARCH_LIMIT per content type).
+        async activity({ actor, contentType, action, from, to, q, page, pageSize, types }) {
+          const empty = { results: [], pagination: { page, pageSize, total: 0, pageCount: 0 }, actors: [] };
+          if (contentType && !types.includes(contentType)) return empty;
+          const where = {
+            contentType: contentType || { $in: types },
+            ...actor && { actor },
+            ...action && { action },
+            ...(from || to) && { at: { ...from && { $gte: from }, ...to && { $lte: to } } }
+          };
+          if (q) {
+            const matches = [];
+            for (const uid of contentType ? [contentType] : types) {
+              const main = await self.mainField(uid);
+              const found = new Set(main ? (await strapi.db.query(uid).findMany({ select: ["documentId"], where: { [main]: { $containsi: q } }, limit: SEARCH_LIMIT })).map((row) => row.documentId) : []);
+              for (const row of await strapi.db.query(TRASH_UID).findMany({ select: ["relatedDocumentId"], where: { contentType: uid, title: { $containsi: q } }, limit: SEARCH_LIMIT })) found.add(row.relatedDocumentId);
+              if (found.size) matches.push({ contentType: uid, relatedDocumentId: { $in: [...found] } });
+            }
+            if (!matches.length) return { ...empty, actors: await actors() };
+            where.$or = matches;
+          }
+          const [list, total] = await Promise.all([
+            events().findMany({ select: ["id", "contentType", "relatedDocumentId", "locale", "action", "actor", "actorName", "at", "summary"], where, orderBy: [{ at: "desc" }, { id: "desc" }], offset: (page - 1) * pageSize, limit: pageSize }),
+            events().count({ where })
+          ]);
+          const docs = /* @__PURE__ */ new Map();
+          for (const uid of [...new Set(list.map((event) => event.contentType))]) {
+            const ids = [...new Set(list.filter((event) => event.contentType === uid).map((event) => event.relatedDocumentId))];
+            const main = strapi.contentTypes?.[uid] ? await self.mainField(uid) : null;
+            const found = strapi.contentTypes?.[uid] ? await strapi.db.query(uid).findMany({ select: ["documentId", "locale", ...main ? [main] : []], where: { documentId: { $in: ids } } }) : [];
+            for (const row of found) {
+              const key = `${uid}|${row.documentId}`;
+              docs.set(key, [...docs.get(key) || [], { locale: row.locale ?? null, title: main && row[main] != null ? String(row[main]) : null }]);
+            }
+            const gone = ids.filter((id) => !docs.has(`${uid}|${id}`));
+            if (gone.length) {
+              for (const row of await strapi.db.query(TRASH_UID).findMany({ select: ["relatedDocumentId", "title"], where: { contentType: uid, relatedDocumentId: { $in: gone } }, orderBy: { id: "desc" } }))
+                if (!docs.has(`trash|${uid}|${row.relatedDocumentId}`)) docs.set(`trash|${uid}|${row.relatedDocumentId}`, row.title);
+            }
+          }
+          const results = list.map((event) => {
+            const rows2 = docs.get(`${event.contentType}|${event.relatedDocumentId}`) || [];
+            const own = rows2.find((row) => row.locale === (event.locale ?? null));
+            if (event.action === "purge") return { ...event, exists: false, title: event.summary?.title ?? null };
+            return { ...event, exists: Boolean(own), title: (own || rows2[0])?.title ?? docs.get(`trash|${event.contentType}|${event.relatedDocumentId}`) ?? null };
+          });
+          return { results, pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) }, actors: await actors() };
+        },
+        // Nightly, in batches, idempotent (two instances running it is harmless): events past eventDays are deleted;
+        // snapshots past retentionDays, or beyond maxSnapshots per document (newest kept), are emptied. Never touches media.
+        async purge(now = Date.now()) {
+          const history = await self.config();
+          const { snapshotsBefore, eventsBefore } = retention(history, now);
+          const counts = { events: 0, expired: 0, excess: 0 };
+          const batches = async (key, query, apply) => {
+            for (; ; ) {
+              const ids = (await events().findMany({ select: ["id"], limit: BATCH, ...query })).map((row) => row.id);
+              if (ids.length) await apply({ id: { $in: ids } });
+              counts[key] += ids.length;
+              if (ids.length < BATCH) return;
+            }
+          };
+          const empty = (where) => events().updateMany({ where, data: { snapshot: null, size: 0 } });
+          await batches("events", { where: { at: { $lt: eventsBefore } }, orderBy: { id: "asc" } }, (where) => events().deleteMany({ where }));
+          await batches("expired", { where: { at: { $lt: snapshotsBefore }, size: { $gt: 0 } }, orderBy: { id: "asc" } }, empty);
+          const meta = strapi.db.metadata.get(EVENT_UID);
+          const column = (name) => meta.attributes[name].columnName || name;
+          const crowded = await strapi.db.connection(meta.tableName).select({ uid: column("contentType"), documentId: column("relatedDocumentId") }).where(column("size"), ">", 0).groupBy(column("contentType"), column("relatedDocumentId")).havingRaw("count(*) > ?", [history.maxSnapshots]);
+          for (const { uid, documentId } of crowded) await batches("excess", {
+            where: { contentType: uid, relatedDocumentId: documentId, size: { $gt: 0 } },
+            orderBy: [{ at: "desc" }, { id: "desc" }],
+            offset: history.maxSnapshots
+          }, empty);
+          return counts;
+        }
+      };
+      return self;
+    }
+    function registerHistory2(strapi) {
+      if (!strapi.documents?.use) return;
+      const service = () => strapi.plugin(PLUGIN2).service("history");
+      const warn = (message, error) => strapi.log.error(`[${PLUGIN2}] ${message}: ${error?.message || error}`);
+      strapi.documents.use(async (ctx, next) => {
+        const action = CAPTURED[ctx.action];
+        if (!action || !String(ctx.uid || "").startsWith("api::") || strapi.plugin(PLUGIN2).config("disabled") === true || restoring.getStore()) return next();
+        const history = service();
+        const params = ctx.params || {};
+        if (action === "delete") {
+          const config = params.documentId ? await history.config() : null;
+          if (!config || !history.covers(config, ctx.uid)) return next();
+          return strapi.db.transaction(async () => {
+            const actor2 = actorOf(strapi), trash = strapi.plugin(PLUGIN2).service("trash");
+            const published = strapi.getModel(ctx.uid)?.options?.draftAndPublish === true;
+            let locales2, entries, live, incoming;
+            try {
+              locales2 = await history.scope(ctx.uid, params.locale);
+              entries = await history.rows(ctx.uid, params.documentId, locales2);
+              live = published ? await history.rows(ctx.uid, params.documentId, locales2, true) : [];
+              incoming = await trash.incoming(ctx.uid, new Map([...entries.map((row) => [row.id, { locale: row.locale, published: false }]), ...live.map((row) => [row.id, { locale: row.locale, published: true }])]));
+            } catch (error) {
+              warn("reading the document before a delete failed", error);
+              fail2(`The version history could not record this delete, so nothing was deleted (${error.message}).`);
+            }
+            const result2 = await next();
+            try {
+              for (const entry of entries) await history.record({ uid: ctx.uid, documentId: params.documentId, locale: entry.locale ?? null, action, entry, actor: actor2 });
+              if (entries.length || live.length) await trash.record({ uid: ctx.uid, documentId: params.documentId, locales: locales2, drafts: entries, published: live, incoming, actor: actor2, days: config.trashDays });
+            } catch (error) {
+              warn("recording a delete failed, the delete was rolled back", error);
+              fail2(`The version history could not record this delete, so nothing was deleted (${error.message}).`);
+            }
+            return result2;
+          });
+        }
+        let covered = false;
+        try {
+          covered = history.covers(await history.config(), ctx.uid);
+        } catch (error) {
+          warn("reading the history settings failed, this change is not recorded", error);
+        }
+        if (!covered) return next();
+        const actor = actorOf(strapi);
+        const result = await next();
+        const documentId = ["create", "update"].includes(action) ? result?.documentId || params.documentId : params.documentId;
+        const locales = ["publish", "unpublish", "discard"].includes(action) ? [...new Set((result?.entries || []).map((entry) => entry?.locale ?? null))] : ctx.action === "clone" ? null : await history.scope(ctx.uid, params.locale).catch(() => [result?.locale ?? null]);
+        const steps = [[action, action === "publish"]];
+        if (["create", "update"].includes(ctx.action) && params.status === "published" && strapi.getModel(ctx.uid)?.options?.draftAndPublish) steps.push(["publish", true]);
+        for (const [step, published] of steps) {
+          if (locales && !locales.length) continue;
+          try {
+            await history.captureSave({ uid: ctx.uid, action: step, documentId, locales, published, actor });
+          } catch (error) {
+            warn(`recording "${step}" of ${ctx.uid} ${documentId} failed, the change was saved without a version`, error);
+            try {
+              if (documentId) for (const locale of locales || [null]) await history.record({ uid: ctx.uid, documentId, locale, action: step, actor, missing: true });
+            } catch (again) {
+              warn("marking the missing version failed too", again);
+            }
+          }
+        }
+        return result;
+      });
+    }
+    function registerPurge2(strapi) {
+      if (!strapi.documents?.use || !strapi.cron?.add) return;
+      strapi.cron.add({ [CRON2]: { options: "0 3 * * *", task: async () => {
+        try {
+          const counts = await strapi.plugin(PLUGIN2).service("history").purge();
+          if (counts.events || counts.expired || counts.excess) strapi.log.info(`[${PLUGIN2}] history purge: ${counts.events} events deleted, ${counts.expired + counts.excess} snapshots emptied`);
+        } catch (error) {
+          strapi.log.error(`[${PLUGIN2}] history purge failed: ${error?.message || error}`);
+        }
+        try {
+          const count = await strapi.plugin(PLUGIN2).service("trash").purge();
+          if (count) strapi.log.info(`[${PLUGIN2}] trash purge: ${count} expired entries deleted`);
+        } catch (error) {
+          strapi.log.error(`[${PLUGIN2}] trash purge failed: ${error?.message || error}`);
+        }
+      } } });
+    }
+    var DOCUMENT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+    var LOCALE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+    var can = (strapi, ctx, uid, action = "read") => {
+      try {
+        return !strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: uid }).cannot[action]();
+      } catch {
+        return false;
+      }
+    };
+    var canRead = (strapi, ctx, uid) => can(strapi, ctx, uid);
+    var readableTypes = (strapi, ctx) => Object.keys(strapi.contentTypes || {}).filter((uid) => uid.startsWith("api::") && canRead(strapi, ctx, uid));
+    var ACTOR = /^(system|(admin|token|user):\d{1,15})$/;
+    var int = (value, fallback, max) => {
+      if (value === void 0 || value === "") return fallback;
+      const n = Number(value);
+      return Number.isInteger(n) && n >= 1 && n <= max ? n : NaN;
+    };
+    var date = (value) => {
+      if (!value) return null;
+      const time = Date.parse(value);
+      return typeof value === "string" && value.length <= 40 && Number.isFinite(time) ? new Date(time) : NaN;
+    };
+    var historyController2 = ({ strapi }) => ({
+      async list(ctx) {
+        const { uid, documentId } = ctx.params || {};
+        const locale = ctx.query?.locale || "";
+        if (!String(uid).startsWith("api::") || !strapi.contentTypes?.[uid] || !DOCUMENT_ID.test(documentId || "") || locale && !LOCALE.test(locale)) return ctx.badRequest("Invalid content type, document or locale");
+        if (!canRead(strapi, ctx, uid)) return ctx.forbidden();
+        const history = strapi.plugin(PLUGIN2).service("history");
+        ctx.body = { results: await history.list({ uid, documentId, locale: (await history.scope(uid, locale || void 0))[0] }) };
+      },
+      async find(ctx) {
+        const id = Number(ctx.params?.id);
+        if (!Number.isInteger(id) || id <= 0) return ctx.badRequest("Invalid event");
+        const found = await strapi.plugin(PLUGIN2).service("history").find(id);
+        if (!found || !canRead(strapi, ctx, found.event.contentType)) return ctx.notFound();
+        ctx.body = found;
+      },
+      async activity(ctx) {
+        const { actor = "", contentType = "", action = "", q = "" } = ctx.query || {};
+        const page = int(ctx.query?.page, 1, 1e4), pageSize = int(ctx.query?.pageSize, 25, 100), from = date(ctx.query?.from), to = date(ctx.query?.to);
+        if ([actor, contentType, action, q].some((value) => typeof value !== "string") || actor && !ACTOR.test(actor) || contentType && !/^api::[\w-]+\.[\w-]+$/.test(contentType) || action && !ACTIONS.includes(action) || q.length > 100 || [page, pageSize, from, to].some((value) => Number.isNaN(value))) return ctx.badRequest("Invalid filters");
+        const history = strapi.plugin(PLUGIN2).service("history");
+        const types = readableTypes(strapi, ctx);
+        ctx.body = {
+          ...await history.activity({ actor, contentType, action, from, to, q: q.trim(), page, pageSize, types }),
+          enabled: Boolean((await history.config()).enabled) && strapi.plugin(PLUGIN2).config("disabled") !== true,
+          types: types.map((uid) => ({ uid, displayName: strapi.contentTypes[uid].info?.displayName || uid, kind: strapi.contentTypes[uid].kind, localized: Boolean(strapi.contentTypes[uid].pluginOptions?.i18n?.localized) }))
+        };
+      }
+    });
+    module2.exports = { EVENT_UID, ACTIONS, CAPTURED, CRON: CRON2, BATCH, eventContentType: eventContentType2, covers: covers2, retention, actorOf, refsOf, can, readableTypes, historyService: historyService2, registerHistory: registerHistory2, registerPurge: registerPurge2, historyController: historyController2 };
+  }
+});
+
 // server/index.js
-var { PLUGIN, TEMPLATES, 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 { trashContentType, trashService, trashController } = require_trash();
+var STRAPI5 = true;
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
 var LEGACY_PLUGIN = "block-picker";
 async function readSettings(strapi) {
@@ -491,6 +1515,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 +1609,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 +1628,29 @@ 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 ? [
+        ["history.read", "Read version history"],
+        ["activity.read", "Read content activity"],
+        ["trash.read", "Read the trash"],
+        ["trash.restore", "Restore from the trash"],
+        ["trash.purge", "Delete from the trash forever"]
+      ].map(([uid, displayName]) => ({ section: "plugins", displayName, uid, pluginName: PLUGIN })) : []
     ]);
     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 and the trash (Strapi 5): hidden from the Content Manager and the Content-Type Builder.
+  contentTypes: STRAPI5 ? { event: eventContentType, trash: trashContentType } : {},
   services: { settings: ({ strapi }) => {
     let project;
     const projectDefaults = () => {
@@ -614,18 +1658,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 +1698,7 @@ module.exports = {
         return get();
       }
     };
-  } },
+  }, ...STRAPI5 && { history: historyService, trash: trashService } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -666,11 +1725,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 +1766,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 +1791,8 @@ module.exports = {
         await store(strapi).set({ key: `prefs:${id}`, value });
         ctx.body = value;
       }
-    })
+    }),
+    ...STRAPI5 && { history: historyController, trash: trashController }
   },
   routes: { admin: { type: "admin", routes: [
     { method: "GET", path: "/catalog", handler: "catalog.find", config: { policies: ["admin::isAuthenticatedAdmin"] } },
@@ -738,6 +1805,21 @@ module.exports = {
         name: "admin::hasPermissions",
         config: { actions: [`plugin::${PLUGIN}.settings.${action}`] }
       }] }
-    }))
+    })),
+    ...STRAPI5 ? [
+      ["GET", "/history/:uid/:documentId", "history.list", "history.read"],
+      ["GET", "/history-events/:id", "history.find", "history.read"],
+      ["GET", "/activity", "history.activity", "activity.read"],
+      ["GET", "/trash", "trash.list", "trash.read"],
+      ["GET", "/trash/:id", "trash.find", "trash.read"],
+      ["GET", "/trash/:id/check", "trash.check", "trash.restore"],
+      ["POST", "/trash/:id/restore", "trash.restore", "trash.restore"],
+      ["DELETE", "/trash/:id", "trash.remove", "trash.purge"]
+    ].map(([method, path, handler, action]) => ({
+      method,
+      path,
+      handler,
+      config: { policies: ["admin::isAuthenticatedAdmin", { name: "admin::hasPermissions", config: { actions: [`plugin::${PLUGIN}.${action}`] } }] }
+    })) : []
   ] } }
 };