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

package/dist/server.cjs

@@ -146,24 +146,37 @@ var require_settings = __commonJS({
         duplicate: true,
         clipboard: true,
         // Edit view labels that are still the raw attribute name read as "Mobile columns count" (see README "Field labels").
-        friendlyLabels: true
+        friendlyLabels: true,
+        // Page preview pane (Strapi 5): which toolbar controls show, in order, and the width menu's entries.
+        previewToolbar: ["modes", "history", "devices", "status", "actions"],
+        previewDevices: ["fit", "mobile", "tablet", "desktop"]
       },
       // Per content type (only the ones with a Dynamic Zone): { enabled: false } turns the plugin off there;
       // previewMode overrides editor.previewMode as the mode the edit view opens in. Absent means the global behaviour.
       contentTypes: {},
       // Version history (Strapi 5, see README "Version history"): off until turned on. contentTypes: 'all' (every api:: type)
-      // or a list of uids. Snapshots are kept retentionDays and at most maxSnapshots per document; events eventDays.
-      history: { enabled: false, contentTypes: "all", retentionDays: 90, maxSnapshots: 100, eventDays: 365 }
+      // 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 || {};
@@ -180,7 +193,8 @@ var require_settings = __commonJS({
       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
+      eventDays: days,
+      trashDays: days
     };
     var TYPOLOGIES2 = ["hero", "text", "media", "listing", "cards", "cta", "form", "layout"];
     var TAG = /^[^<>\n]{1,24}$/;
@@ -281,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");
@@ -317,7 +331,7 @@ 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");
@@ -342,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);
@@ -374,22 +390,25 @@ var require_settings = __commonJS({
       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 };
+    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));
@@ -613,6 +632,453 @@ var require_diff = __commonJS({
   }
 });
 
+// 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) {
@@ -620,13 +1086,16 @@ var require_history = __commonJS({
     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"];
+    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",
@@ -642,7 +1111,8 @@ var require_history = __commonJS({
         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.
+        // { 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" },
@@ -705,6 +1175,11 @@ var require_history = __commonJS({
       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;
@@ -727,7 +1202,7 @@ var require_history = __commonJS({
         },
         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 }) {
+        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);
@@ -740,6 +1215,7 @@ var require_history = __commonJS({
               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).
@@ -749,6 +1225,16 @@ var require_history = __commonJS({
         },
         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 };
@@ -772,13 +1258,7 @@ var require_history = __commonJS({
           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 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 } } }
@@ -787,6 +1267,56 @@ var require_history = __commonJS({
           }
           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()) {
@@ -823,16 +1353,21 @@ var require_history = __commonJS({
       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();
+        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") {
-          if (!params.documentId || !history.covers(await history.config(), ctx.uid)) return next();
+          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);
-            let entries;
+            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 {
-              entries = await history.rows(ctx.uid, params.documentId, await history.scope(ctx.uid, params.locale));
+              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}).`);
@@ -840,6 +1375,7 @@ var require_history = __commonJS({
             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}).`);
@@ -885,17 +1421,36 @@ var require_history = __commonJS({
         } 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 canRead = (strapi, ctx, uid) => {
+    var can = (strapi, ctx, uid, action = "read") => {
       try {
-        return !strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: uid }).cannot.read();
+        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 || {};
@@ -911,9 +1466,21 @@ var require_history = __commonJS({
         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, historyService: historyService2, registerHistory: registerHistory2, registerPurge: registerPurge2, historyController: historyController2 };
+    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 };
   }
 });
 
@@ -922,6 +1489,7 @@ var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, valida
 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";
@@ -1061,7 +1629,13 @@ module.exports = {
     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 },
-      ...STRAPI5 ? [{ section: "plugins", displayName: "Read version history", uid: "history.read", 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();
@@ -1075,8 +1649,8 @@ module.exports = {
   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 } : {},
+  // 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 = () => {
@@ -1124,7 +1698,7 @@ module.exports = {
         return get();
       }
     };
-  }, ...STRAPI5 && { history: historyService } },
+  }, ...STRAPI5 && { history: historyService, trash: trashService } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -1218,7 +1792,7 @@ module.exports = {
         ctx.body = value;
       }
     }),
-    ...STRAPI5 && { history: historyController }
+    ...STRAPI5 && { history: historyController, trash: trashController }
   },
   routes: { admin: { type: "admin", routes: [
     { method: "GET", path: "/catalog", handler: "catalog.find", config: { policies: ["admin::isAuthenticatedAdmin"] } },
@@ -1232,11 +1806,20 @@ module.exports = {
         config: { actions: [`plugin::${PLUGIN}.settings.${action}`] }
       }] }
     })),
-    ...STRAPI5 ? [["/history/:uid/:documentId", "list"], ["/history-events/:id", "find"]].map(([path, handler]) => ({
-      method: "GET",
+    ...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: `history.${handler}`,
-      config: { policies: ["admin::isAuthenticatedAdmin", { name: "admin::hasPermissions", config: { actions: [`plugin::${PLUGIN}.history.read`] } }] }
+      handler,
+      config: { policies: ["admin::isAuthenticatedAdmin", { name: "admin::hasPermissions", config: { actions: [`plugin::${PLUGIN}.${action}`] } }] }
     })) : []
   ] } }
 };