@strapi/upload 5.51.2 → 5.52.1

package/dist/admin/src/future/pages/Assets/components/FolderActionsMenu.d.ts

@@ -0,0 +1,21 @@
+import type { Folder } from '../../../../../../shared/contracts/folders';
+import type { DragFolderData } from '../../../types/dnd';
+interface FolderActionsMenuProps {
+    folder: Folder;
+    /** Drag data for this folder, so the move dialog validates against its real parent. */
+    dragData: DragFolderData;
+}
+/**
+ * The "..." menu on a folder row/card. Always acts on that one folder, whatever
+ * the current multi-selection is (the bulk actions bar is the selection-scoped
+ * affordance). It reuses the shared move and delete dialogs, which mount only
+ * while open.
+ *
+ * A successful move or delete deselects this one folder and leaves the rest of
+ * the selection intact: they only invalidate RTK tags, so without it a
+ * `folder:<id>` key for a folder that no longer lives where the selection thinks
+ * it does would linger. A rename leaves the id valid and the folder in place, so
+ * it touches the selection not at all.
+ */
+export declare const FolderActionsMenu: ({ folder, dragData }: FolderActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/future/pages/Assets/components/FolderFormDialog.d.ts

@@ -0,0 +1,16 @@
+interface FolderFormDialogBaseProps {
+    open: boolean;
+    onClose: () => void;
+    /** Sent as `parent`. Create: the folder being created in. Rename: the folder's existing parent. */
+    parentFolderId: number | null;
+}
+type FolderFormDialogProps = FolderFormDialogBaseProps & ({
+    mode: 'create';
+    parentFolderName: string;
+} | {
+    mode: 'rename';
+    folderId: number;
+    initialName: string;
+});
+export declare const FolderFormDialog: (props: FolderFormDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/future/pages/Assets/hooks/useAssetSelection.d.ts

@@ -27,6 +27,8 @@ export interface AssetSelection {
     selectRange: (orderedKeys: ItemKey[], targetKey: ItemKey) => void;
     /** Header checkbox — selects every rendered item (folders and assets). */
     selectAll: (orderedKeys: ItemKey[]) => void;
+    /** Row-level "..." menu — drops one key when its item leaves the list (move, delete). */
+    deselect: (key: ItemKey) => void;
     /** Close button / folder navigation / list-identity changes. */
     clear: () => void;
 }

package/dist/admin/src/future/pages/Assets/hooks/useBusyAssets.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+/**
+ * Which assets have a long-running mutation in flight, so the list can show it
+ * on the item itself.
+ *
+ * The mutation stays where it is triggered — the row's "..." menu — but the
+ * feedback has to render on the row or card, which is an ancestor of it. The
+ * menu sits in a leaf `<td>` (table) / footer `Flex` (grid), so an overlay
+ * mounted there would cover the button and nothing else. Rather than hoist the
+ * mutation up into both `AssetRow` and `AssetCard` (duplicating it, and moving
+ * it away from the control that owns it), the busy flag travels up through
+ * context and the ancestor renders the overlay.
+ *
+ * Scoped per asset id rather than a single boolean: a replace on one row must
+ * not blank out every other row. Modelled on `isMovePending` in
+ * `AssetsDndProvider`, which does the same thing for drag-moves — that one is
+ * list-wide because a move genuinely blocks the whole list.
+ */
+export interface BusyAssets {
+    /** Whether this asset has a mutation in flight. */
+    isBusy: (id: number) => boolean;
+    /** The message to show while it is, or `null`. */
+    getBusyMessage: (id: number) => string | null;
+    /**
+     * Marks the asset busy and returns the release function. Pair it with
+     * `try`/`finally` so the flag clears on failure too.
+     */
+    markBusy: (id: number, message: string) => () => void;
+}
+export declare const BusyAssetsProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<BusyAssets | null>>;
+/**
+ * Optional by design: `AssetActionsMenu`, `AssetRow` and `AssetCard` are also
+ * rendered in tests and in the asset picker, outside this provider. Without it
+ * the mutation still runs, it just shows no row-level feedback.
+ */
+export declare const useBusyAssetsOptional: () => BusyAssets | null;

package/dist/admin/src/future/pages/Assets/hooks/useInfiniteAssets.d.ts

@@ -6,16 +6,30 @@ interface UseInfiniteAssetsOptions {
     search?: string;
     /** Extra `filters[$and]` entries for the files query. */
     filters?: Record<string, unknown>[];
-    /**
-     * Stable fingerprint of `filters` — a change resets the accumulated pages
-     * (the array identity itself changes every render).
-     */
-    filtersKey?: string;
     /** Structural switch: an `is [folder]`-only type badge means no file can match. */
     enabled?: boolean;
 }
-declare const useInfiniteAssets: ({ folder, sort, search, filters, filtersKey, enabled, }?: UseInfiniteAssetsOptions) => {
+/**
+ * Infinite scroll over `/upload/files`, keeping one accumulated slot per page.
+ *
+ * The caller MUST render the returned `subscribers` node — that is what keeps
+ * every loaded page subscribed, so `{Asset, LIST}` invalidations keep the whole
+ * list consistent rather than only the current page.
+ */
+declare const useInfiniteAssets: ({ folder, sort, search, filters, enabled, }?: UseInfiniteAssetsOptions) => {
     assets: File[];
+    subscribers: null;
+    pagination: undefined;
+    isLoading: boolean;
+    isFetchingMore: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => void;
+    error: undefined;
+} | {
+    assets: File[];
+    subscribers: import("react").FunctionComponentElement<{
+        children?: import("react").ReactNode | undefined;
+    }>;
     pagination: Pagination | undefined;
     isLoading: boolean;
     isFetchingMore: boolean;

package/dist/admin/src/future/pages/Assets/hooks/useInfiniteScrollSentinel.d.ts

@@ -0,0 +1,41 @@
+interface UseInfiniteScrollSentinelArgs {
+    /** Whether there is a further page to request. */
+    hasNextPage: boolean;
+    /** Whether a subsequent page is already in flight. */
+    isFetchingMore: boolean;
+    /** Called to request the next page. Held in a ref, so it need not be stable. */
+    onLoadMore: () => void;
+    /**
+     * Passed to the `IntersectionObserver`. Read once, when the sentinel node
+     * attaches — changing it afterwards does NOT rebuild the observer, so a
+     * later `threshold`/`rootMargin` is silently ignored. Pass a stable, ideally
+     * module-level, object.
+     */
+    options?: IntersectionObserverInit;
+}
+/**
+ * Infinite-scroll trigger for the media library list.
+ *
+ * Returns a callback ref to place on a sentinel element rendered after the last
+ * row. Three deliberate choices:
+ *
+ * 1. **Loading is driven only by fresh observer readings.** A fetch fires from
+ *    the `IntersectionObserver` callback — never from a state/prop change — so
+ *    it can't react to a stale `isIntersecting` from before newly loaded rows
+ *    rendered (which fetched an extra page on every trigger).
+ *
+ * 2. **Each settled page re-observes the sentinel.** An `IntersectionObserver`
+ *    only fires on a *transition*. When the sentinel stays on screen (a page
+ *    that doesn't fill the viewport — tall viewport, short page, grid fitting
+ *    the whole page) it would never fire again and loading would stall. So when
+ *    `isFetchingMore` settles back to false we re-observe, forcing a fresh
+ *    reading against the new layout: still on screen → load the next page;
+ *    viewport now filled → stop.
+ *
+ * 3. **A callback ref, not a stable object ref.** The sentinel only mounts once
+ *    the first page has rendered (the list shows a loader before that). A
+ *    callback ref (re)binds the observer exactly when the node mounts/unmounts,
+ *    so the observer can't miss a sentinel that appears after the hook first ran.
+ */
+export declare const useInfiniteScrollSentinel: ({ hasNextPage, isFetchingMore, onLoadMore, options, }: UseInfiniteScrollSentinelArgs) => (node: HTMLElement | null) => void;
+export {};

package/dist/admin/src/future/pages/Assets/utils/selection.d.ts

@@ -25,6 +25,16 @@ export declare const createEmptySelection: () => SelectionState;
  * The toggled key becomes the new anchor.
  */
 export declare const toggleSelection: (state: SelectionState, key: ItemKey) => SelectionState;
+/**
+ * Subtractive counterpart to {@link toggleSelection} — removes a key without the
+ * add-if-absent ambiguity, leaving the rest of the selection alone. Used when a
+ * single-item affordance (a row's "..." menu) makes exactly one key stale.
+ *
+ * Idempotent: removing a key that was never selected is a no-op. The anchor is
+ * dropped only when it is the removed key, so a Shift+click range built around
+ * other rows survives.
+ */
+export declare const deselect: (state: SelectionState, key: ItemKey) => SelectionState;
 /**
  * Shift+click — selects the contiguous range between the current anchor and the
  * target in render order, replacing the current selection. The anchor stays put.

package/dist/admin/src/future/services/api.d.ts

@@ -1,5 +1,5 @@
 import { Dispatch } from '@reduxjs/toolkit';
-import type { CreateFilesStream, File as UploadedFile, UnstableGenerateAIMetadata, UploadFileInfo } from '../../../../shared/contracts/files';
+import type { CreateFilesStream, File as UploadedFile, GenerateAIMetadata, UploadFileInfo } from '../../../../shared/contracts/files';
 interface UploadFilesArgs {
     formData: FormData;
     totalFiles: number;
@@ -54,10 +54,9 @@ export declare const maybeGenerateMetadata: ({ file, index, uploadId, enabled, d
 }) => void;
 declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, import("@reduxjs/toolkit/dist/query/endpointDefinitions").UpdateDefinitions<{}, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", never> & {
     /**
-     * Upload files to `/upload/unstable/upload-file`, one request per file,
-     * through a worker pool of `concurrency` parallel requests (default 1 =
-     * sequential). Real per-file byte progress comes from
-     * `XHR.upload.onprogress`.
+     * Upload files to `/upload/files`, one request per file, through a worker
+     * pool of `concurrency` parallel requests (default 1 = sequential). Real
+     * per-file byte progress comes from `XHR.upload.onprogress`.
      */
     uploadFiles: import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">;
     /**
@@ -92,9 +91,9 @@ declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/t
      */
     generateAiMetadata: import("@reduxjs/toolkit/query").MutationDefinition<{
         fileIds: number[];
-    }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UnstableGenerateAIMetadata.FileResult[], "adminApi">;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", GenerateAIMetadata.FileResult[], "adminApi">;
 }, "adminApi", "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
 export declare const useUploadFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFileSilentlyMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadEntry, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile, "adminApi">>, useRetryCancelledFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFromUrlsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">>, useGenerateAiMetadataMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
     fileIds: number[];
-}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UnstableGenerateAIMetadata.FileResult[], "adminApi">>;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", GenerateAIMetadata.FileResult[], "adminApi">>;
 export { uploadApi };

package/dist/admin/src/future/services/folders.d.ts

@@ -21,7 +21,12 @@ interface BulkMoveParams {
     /** `null` moves the items to the root of the Media Library. */
     destinationFolderId: number | null;
 }
-export declare const useCreateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Pick<Folder, "name" | "parent">, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useGetFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetFoldersParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
+export declare const useCreateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Pick<Folder, "name" | "parent">, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useUpdateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
+    id: number;
+} & {
+    name: string;
+    parent: number | null;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useGetFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetFoldersParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
     id: number;
 }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", FolderWithCounts, "adminApi">>, useGetAllFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderStructureQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", FolderNode[], "adminApi">>, useBulkMoveMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<BulkMoveParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", {
     data: {

package/dist/admin/src/future/utils/buildDragSetFromSelection.d.ts

@@ -1,11 +1,12 @@
+import { type ItemLocations } from './itemLocations';
 import type { DragItemData } from '../types/dnd';
 /**
  * Reconstruct the drag set from a bulk-actions selection so the dialog can feed
  * the exact same `DragItemData[]` into `computeValidDropTargets` / the canonical
  * `canDropItemOnFolder` predicate that pointer drag uses.
  *
- * Selection is page-scoped to the current folder, so every selected item shares
- * `currentFolderId` as its location (files → `folderId`, folders → `parentId`).
+ * Each item's location comes from the loaded row, not from the folder currently
+ * open: search results are global, so a selected item can live anywhere.
  * Names are irrelevant to drop validation, so they are left empty.
  */
-export declare const buildDragSetFromSelection: (selectedIds: ReadonlySet<number>, selectedFolderIds: ReadonlySet<number>, currentFolderId: number | null) => DragItemData[];
+export declare const buildDragSetFromSelection: (selectedIds: ReadonlySet<number>, selectedFolderIds: ReadonlySet<number>, locations: ItemLocations, fallbackFolderId: number | null) => DragItemData[];

package/dist/admin/src/future/utils/formatMoveSuccessMessage.d.ts

@@ -2,7 +2,13 @@ import type { IntlShape } from 'react-intl';
 interface FormatMoveSuccessArgs {
     formatMessage: IntlShape['formatMessage'];
     count: number;
-    source: string;
+    /**
+     * Leaf name of the folder the items came from, or `null` when the move spans
+     * several source folders and no single one can be named — a global-search
+     * selection can hold items from anywhere. The wording then omits the source
+     * rather than naming one folder and implying the rest came from it too.
+     */
+    source: string | null;
     destination: string;
 }
 /**

package/dist/admin/src/future/utils/getRelationId.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalise a to-one relation down to its id.
+ *
+ * The contracts type `File['folder']` and `Folder['parent']` as ids, but the
+ * admin populates both (`populate: { folder: true }` on `/upload/files`,
+ * `populate: { parent: true }` on `/upload/folders`), so the wire value is an
+ * object. Only the id is ever read — move validation compares locations by id.
+ */
+export declare const getRelationId: (relation: number | string | {
+    id?: number;
+} | null | undefined) => number | null;

package/dist/admin/src/future/utils/isEventFromWithin.d.ts

@@ -0,0 +1,11 @@
+import type { SyntheticEvent } from 'react';
+/**
+ * True when the event really originated inside `currentTarget`'s DOM subtree.
+ *
+ * Portaled content (Radix menus, modals, select popovers) bubbles through the
+ * React tree, so a row's handlers see events coming from dialogs rendered by
+ * its own children. Guarding on DOM containment keeps those out — without
+ * calling `stopPropagation`, which would also kill the native event before it
+ * reaches `document`, where Radix listens in order to dismiss its layers.
+ */
+export declare const isEventFromWithin: (event: SyntheticEvent) => boolean;

package/dist/admin/src/future/utils/itemLocations.d.ts

@@ -0,0 +1,31 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+/**
+ * Where each loaded item actually lives, keyed by id.
+ *
+ * Search results are global, so the folder currently open (`?folder=`) says
+ * nothing about a selected item's location. The loaded lists do: the server
+ * populates `folder` on `/upload/files` and `parent` on `/upload/folders`.
+ *
+ * `undefined` means "not in the loaded list" and is distinct from `null`
+ * ("lives at the root") — the two lead to different move validation.
+ */
+export interface ItemLocations {
+    fileFolderId: (id: number) => number | null | undefined;
+    folderParentId: (id: number) => number | null | undefined;
+}
+/** Every id misses — used where no list is loaded (e.g. an isolated provider). */
+export declare const emptyItemLocations: ItemLocations;
+/**
+ * Build the lookup once per list. Callers memoize on the rows so the identity
+ * stays stable: `BulkMoveDialog` memoizes its destination walk on the items
+ * derived from it.
+ */
+export declare const buildItemLocations: (assets: File[], folders: Folder[]) => ItemLocations;
+/**
+ * Resolve an item's location, falling back to the folder currently open when it
+ * is not in the loaded list. The fallback is unreachable in practice — selection
+ * clears whenever the list identity changes and infinite scroll only appends —
+ * but a stale parent beats silently dropping the item from the move.
+ */
+export declare const locateItem: (locations: ItemLocations, kind: "file" | "folder", id: number, fallbackFolderId: number | null) => number | null;

package/dist/admin/src/future/utils/itemSource.d.ts

@@ -0,0 +1,22 @@
+import type { DragItemData } from '../types/dnd';
+/**
+ * Where an item currently lives, regardless of its kind — folders carry their
+ * location on `parentId`, files on `folderId`.
+ */
+export declare const sourceFolderIdOf: (item: DragItemData) => number | null;
+/**
+ * The one folder every item in a move came from, or `null` when there isn't one.
+ *
+ * A selection made under a global search can hold items from anywhere, so a move
+ * has a nameable source only when the whole set agrees on it. `null` also covers
+ * the empty set. Callers pass the result straight to `formatMoveSuccessMessage`,
+ * which drops the source from the wording rather than crediting one item's
+ * folder to all of them.
+ *
+ * Note `null` is overloaded on purpose at the *label* level: an item at the
+ * Media Library root also has a `null` location, and both cases end up reading
+ * as "no folder to name". Use `hasUniformSource` when the difference matters.
+ */
+export declare const uniformSourceFolderId: (items: DragItemData[]) => number | null;
+/** Whether every item in the set came from the same folder. False for an empty set. */
+export declare const hasUniformSource: (items: DragItemData[]) => boolean;

package/dist/admin/translations/en.json.js

@@ -100,6 +100,9 @@ var en = {
     "upload.progress.maximize": "Maximize",
     "upload.progress.minimize": "Minimize",
     "upload.progress.close": "Close",
+    "beta.badge": "Beta",
+    "beta.notice.close": "Close",
+    "beta.notice.content": "This is a beta version of the Media Library. Some features are still in progress — please report any issue you run into.",
     "bulk.select.label": "Select all assets",
     "button.next": "Next",
     "new": "New",
@@ -116,6 +119,7 @@ var en = {
     "control-card.save-focal-point": "Save focal point",
     "control-card.download": "Download",
     "control-card.edit": "Edit",
+    "control-card.more-actions": "More actions",
     "control-card.remove-selection": "Remove from selection",
     "control-card.replace-media": "Replace Media",
     "control-card.save": "Save",
@@ -133,11 +137,16 @@ var en = {
     "header.actions.add-assets": "Add new assets",
     "header.actions.add-folder": "Add new folder",
     "folder.create.title": "New folder",
+    "folder.create.title-in": "New folder in {folderName}",
     "folder.form.name.label": "Folder name",
     "folder.create.submit": "Create folder",
     "folder.create.form.error.name-required": "Name is required",
     "folder.create.form.error.unknown": "An error occurred while creating the folder",
     "folder.create.success": "Folder has been created",
+    "folder.rename.title": "Rename folder",
+    "folder.rename.submit": "Save",
+    "folder.rename.form.error.unknown": "An error occurred while renaming the folder",
+    "folder.rename.success": "Folder has been renamed",
     "header.actions.add-assets.folder": "folder",
     "header.actions.upload-assets": "Upload assets",
     "header.actions.upload-new-asset": "Upload new asset",
@@ -223,8 +232,19 @@ var en = {
     "list.assets.preview-asset": "Preview for the video at path {path}",
     "list.assets.selected": "{numberFolders, plural, one {1 folder} other {# folders}} - {numberAssets, plural, one {1 asset} other {# assets}}",
     "list-assets-select": "Select {name} asset",
+    "list.assets.actions.replace": "Replace media",
+    "list.assets.actions.copy-link": "Copy link to media",
+    "list.assets.actions.download": "Download media",
+    "list.assets.actions.move": "Move to folder",
+    "list.assets.actions.delete": "Delete",
     "list.assets.type-not-allowed": "This type of file is not allowed.",
     "list.assets.to-upload": "{number, plural, =0 {No asset} one {1 asset} other {# assets}} ready to upload",
+    "list.folder.actions.copy-link": "Copy link to folder",
+    "list.folder.actions.copy-link.success": "Folder link copied.",
+    "list.folder.actions.copy-link.error": "Failed to copy the folder link.",
+    "list.folder.actions.rename": "Rename folder",
+    "list.folder.actions.move": "Move to folder",
+    "list.folder.actions.delete": "Delete folder",
     "list.folder.edit": "Edit folder",
     "list.folder.select": "Select {name} folder",
     "list.folder.subtitle": "{folderCount, plural, one {# folder} other {# folders}}, {filesCount, plural, one {# asset} other {# assets}}",
@@ -317,6 +337,7 @@ var en = {
     "list.table.header.sort": "Sort on {label}",
     "list.table.header.select-all": "Select all",
     "list.table.row.select": "Select {name}",
+    "list.table.row.metadata-missing": "This asset is missing metadata (caption or alternative text).",
     "list.table.content.empty-label": "This field is empty",
     "list.bulk-actions.label": "Bulk actions",
     "list.bulk-actions.selected-count": "{count, plural, =1 {# item selected} other {# items selected}}",
@@ -330,8 +351,11 @@ var en = {
     "list.bulk-actions.move": "Move",
     "list.bulk-actions.move.title": "Move elements to",
     "list.bulk-actions.move.location": "Location",
+    "list.bulk-actions.move.no-destination": "There is no other folder to move this to.",
+    "list.bulk-actions.move.load-error": "Couldn't load the folder list. Please try again.",
     "list.bulk-actions.move.submit": "Move",
     "list.bulk-actions.move.success": "{count, plural, =1 {# element has} other {# elements have}} been moved from {source} to {destination}",
+    "list.bulk-actions.move.success-multiple-sources": "{count, plural, =1 {# element has} other {# elements have}} been moved to {destination}",
     "list.bulk-actions.move.error": "An error occurred while moving the items.",
     "list.bulk-actions.delete": "Delete",
     "list.bulk-actions.delete.confirm.title": "Delete {count, plural, =1 {# item} other {# items}}?",
@@ -364,11 +388,8 @@ var en = {
     "sidebar.tree.expand": "Expand {name}",
     "sidebar.tree.collapse": "Collapse {name}",
     "sidebar.tree.empty": "No folders yet",
-    "sidebar.tree.no-results": "No folders match \"{query}\"",
     "sidebar.tree.loading": "Loading folders...",
-    "sidebar.tree.error": "Could not load folders.",
-    "sidebar.search.label": "Search folders",
-    "sidebar.search.placeholder": "Search folders"
+    "sidebar.tree.error": "Could not load folders."
 };
 
 module.exports = en;

package/dist/admin/translations/en.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/translations/en.json.mjs

@@ -98,6 +98,9 @@ var en = {
     "upload.progress.maximize": "Maximize",
     "upload.progress.minimize": "Minimize",
     "upload.progress.close": "Close",
+    "beta.badge": "Beta",
+    "beta.notice.close": "Close",
+    "beta.notice.content": "This is a beta version of the Media Library. Some features are still in progress — please report any issue you run into.",
     "bulk.select.label": "Select all assets",
     "button.next": "Next",
     "new": "New",
@@ -114,6 +117,7 @@ var en = {
     "control-card.save-focal-point": "Save focal point",
     "control-card.download": "Download",
     "control-card.edit": "Edit",
+    "control-card.more-actions": "More actions",
     "control-card.remove-selection": "Remove from selection",
     "control-card.replace-media": "Replace Media",
     "control-card.save": "Save",
@@ -131,11 +135,16 @@ var en = {
     "header.actions.add-assets": "Add new assets",
     "header.actions.add-folder": "Add new folder",
     "folder.create.title": "New folder",
+    "folder.create.title-in": "New folder in {folderName}",
     "folder.form.name.label": "Folder name",
     "folder.create.submit": "Create folder",
     "folder.create.form.error.name-required": "Name is required",
     "folder.create.form.error.unknown": "An error occurred while creating the folder",
     "folder.create.success": "Folder has been created",
+    "folder.rename.title": "Rename folder",
+    "folder.rename.submit": "Save",
+    "folder.rename.form.error.unknown": "An error occurred while renaming the folder",
+    "folder.rename.success": "Folder has been renamed",
     "header.actions.add-assets.folder": "folder",
     "header.actions.upload-assets": "Upload assets",
     "header.actions.upload-new-asset": "Upload new asset",
@@ -221,8 +230,19 @@ var en = {
     "list.assets.preview-asset": "Preview for the video at path {path}",
     "list.assets.selected": "{numberFolders, plural, one {1 folder} other {# folders}} - {numberAssets, plural, one {1 asset} other {# assets}}",
     "list-assets-select": "Select {name} asset",
+    "list.assets.actions.replace": "Replace media",
+    "list.assets.actions.copy-link": "Copy link to media",
+    "list.assets.actions.download": "Download media",
+    "list.assets.actions.move": "Move to folder",
+    "list.assets.actions.delete": "Delete",
     "list.assets.type-not-allowed": "This type of file is not allowed.",
     "list.assets.to-upload": "{number, plural, =0 {No asset} one {1 asset} other {# assets}} ready to upload",
+    "list.folder.actions.copy-link": "Copy link to folder",
+    "list.folder.actions.copy-link.success": "Folder link copied.",
+    "list.folder.actions.copy-link.error": "Failed to copy the folder link.",
+    "list.folder.actions.rename": "Rename folder",
+    "list.folder.actions.move": "Move to folder",
+    "list.folder.actions.delete": "Delete folder",
     "list.folder.edit": "Edit folder",
     "list.folder.select": "Select {name} folder",
     "list.folder.subtitle": "{folderCount, plural, one {# folder} other {# folders}}, {filesCount, plural, one {# asset} other {# assets}}",
@@ -315,6 +335,7 @@ var en = {
     "list.table.header.sort": "Sort on {label}",
     "list.table.header.select-all": "Select all",
     "list.table.row.select": "Select {name}",
+    "list.table.row.metadata-missing": "This asset is missing metadata (caption or alternative text).",
     "list.table.content.empty-label": "This field is empty",
     "list.bulk-actions.label": "Bulk actions",
     "list.bulk-actions.selected-count": "{count, plural, =1 {# item selected} other {# items selected}}",
@@ -328,8 +349,11 @@ var en = {
     "list.bulk-actions.move": "Move",
     "list.bulk-actions.move.title": "Move elements to",
     "list.bulk-actions.move.location": "Location",
+    "list.bulk-actions.move.no-destination": "There is no other folder to move this to.",
+    "list.bulk-actions.move.load-error": "Couldn't load the folder list. Please try again.",
     "list.bulk-actions.move.submit": "Move",
     "list.bulk-actions.move.success": "{count, plural, =1 {# element has} other {# elements have}} been moved from {source} to {destination}",
+    "list.bulk-actions.move.success-multiple-sources": "{count, plural, =1 {# element has} other {# elements have}} been moved to {destination}",
     "list.bulk-actions.move.error": "An error occurred while moving the items.",
     "list.bulk-actions.delete": "Delete",
     "list.bulk-actions.delete.confirm.title": "Delete {count, plural, =1 {# item} other {# items}}?",
@@ -362,11 +386,8 @@ var en = {
     "sidebar.tree.expand": "Expand {name}",
     "sidebar.tree.collapse": "Collapse {name}",
     "sidebar.tree.empty": "No folders yet",
-    "sidebar.tree.no-results": "No folders match \"{query}\"",
     "sidebar.tree.loading": "Loading folders...",
-    "sidebar.tree.error": "Could not load folders.",
-    "sidebar.search.label": "Search folders",
-    "sidebar.search.placeholder": "Search folders"
+    "sidebar.tree.error": "Could not load folders."
 };
 
 export { en as default };

package/dist/admin/translations/en.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/server/controllers/admin-file.js

@@ -56,7 +56,12 @@ var adminFile = {
         ]);
         ctx.body = body;
     },
-    async getAIMetadataCount (ctx) {
+    /**
+   * `GET /upload/ai-metadata-jobs/pending-count`
+   *
+   * How many images a backfill job would have to process, i.e. those still
+   * missing AI metadata, alongside the total image count.
+   */ async getAIMetadataPendingCount (ctx) {
         const { userAbility } = ctx.state;
         const pm = strapi.service('admin::permission').createPermissionsManager({
             ability: userAbility,
@@ -86,7 +91,14 @@ var adminFile = {
             ctx.badRequest(message);
         }
     },
-    async generateAIMetadata (ctx) {
+    /**
+   * `POST /upload/ai-metadata-jobs`
+   *
+   * Create a backfill job that generates AI metadata for every image still
+   * missing it, and return the job so the client can poll it. Processing runs
+   * detached from this request; see `generateAIMetadata` for the synchronous
+   * counterpart that works on an explicit selection.
+   */ async createAIMetadataJob (ctx) {
         const { userAbility } = ctx.state;
         const pm = strapi.service('admin::permission').createPermissionsManager({
             ability: userAbility,
@@ -135,14 +147,15 @@ var adminFile = {
         }
     },
     /**
-   * Generate AI metadata for an explicit selection of files, synchronously.
+   * `POST /upload/actions/generate-ai-metadata`
    *
-   * Unlike `generateAIMetadata`, no job is created: the request resolves once
-   * every file has been processed and reports the outcome per file, so a single
-   * bad id or a non-image in the selection never fails the whole batch.
+   * Generate AI metadata for the explicit selection of files in the body,
+   * synchronously: the request resolves once every file has been processed and
+   * reports the outcome per file, so a single bad id or a non-image in the
+   * selection never fails the whole batch.
    *
-   * @experimental
-   */ async unstable_generateAIMetadata (ctx) {
+   * For the whole-library backfill, see `createAIMetadataJob`.
+   */ async generateAIMetadata (ctx) {
         const { userAbility } = ctx.state;
         const { body } = ctx.request;
         const pm = strapi.service('admin::permission').createPermissionsManager({
@@ -163,7 +176,12 @@ var adminFile = {
             data: results
         };
     },
-    async getLatestAIMetadataJob (ctx) {
+    /**
+   * `GET /upload/ai-metadata-jobs/latest`
+   *
+   * The most recent still-active backfill job, so a client that reloads mid-run
+   * can pick the progress bar back up. 404s when nothing is running.
+   */ async getLatestAIMetadataJob (ctx) {
         if (await index.getService('aiMetadata').isEnabled() === false) {
             return ctx.notFound();
         }