@strapi/upload 5.51.2 → 5.52.0

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

@@ -1,3 +1,4 @@
+import { type ItemLocations } from '../../../utils/itemLocations';
 import type { File } from '../../../../../../shared/contracts/files';
 interface BulkActionsBarProps {
     /**
@@ -9,6 +10,12 @@ interface BulkActionsBarProps {
      * every selected asset id is guaranteed to appear here.
      */
     assets?: File[];
+    /**
+     * Real location of every loaded row, so the move dialog validates each
+     * selected item against its own parent. Defaults to a lookup that misses
+     * everything, which falls back to the folder currently open.
+     */
+    locations?: ItemLocations;
 }
-export declare const BulkActionsBar: ({ assets }: BulkActionsBarProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const BulkActionsBar: ({ assets, locations, }: BulkActionsBarProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,13 +1,24 @@
+import type { DragItemData } from '../../../types/dnd';
 interface BulkMoveDialogProps {
     open: boolean;
     onClose: () => void;
+    /**
+     * Items to move, as drag data so destination validation sees each item's real
+     * parent — the current folder is not a reliable stand-in once results come
+     * from a global search.
+     */
+    items: DragItemData[];
+    onSuccess?: () => void;
 }
 /**
- * "Move elements to" modal for the bulk actions bar. Moves the current
- * selection (assets and/or folders) into the picked destination folder via
- * `POST /upload/actions/bulk-move`. The mutation invalidates the asset list,
- * folder list and the sidebar folder-structure, so both panes refresh on
- * success. On failure the modal stays open so the user can retry or cancel.
+ * "Move elements to" modal. Moves the given items (assets and/or folders) into
+ * the picked destination folder via `POST /upload/actions/bulk-move`. The
+ * mutation invalidates the asset list, folder list and the sidebar
+ * folder-structure, so both panes refresh on success. On failure the modal stays
+ * open so the user can retry or cancel.
+ *
+ * Used both by the bulk actions bar (the whole selection) and by a folder's
+ * actions menu (that one folder).
  */
-export declare const BulkMoveDialog: ({ open, onClose }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BulkMoveDialog: ({ open, onClose, items, onSuccess }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,9 @@
+interface BusyOverlayProps {
+    /** Shown next to the spinner, and read out as the loader's accessible label. */
+    children: string;
+    zIndex?: number;
+    /** Hides the label, leaving the spinner — for containers too small to fit text. */
+    hideLabel?: boolean;
+}
+export declare const BusyOverlay: ({ children, zIndex, hideLabel }: BusyOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+interface DeleteItemsDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** Explicit delete target — assets and/or folders, by id. */
+    target: {
+        fileIds: number[];
+        folderIds: number[];
+    };
+    /** Called after a successful delete, before the toast. */
+    onSuccess?: () => void;
+    /**
+     * Mirrors the in-flight state out to the caller, so a host that has its own
+     * controls (the bulk actions bar) can disable them for the duration.
+     */
+    onPendingChange?: (pending: boolean) => void;
+}
+/**
+ * Confirm dialog for `POST /upload/actions/bulk-delete`. Fully controlled: the
+ * caller owns `open` and renders its own trigger. Shared by the bulk actions bar
+ * (selection-scoped) and the per-folder actions menu (item-scoped), so the
+ * target is always passed in explicitly rather than read from the selection.
+ *
+ * Deleting a folder cascades server-side, which is why the copy warns about
+ * folder contents even for a single item.
+ */
+export declare const DeleteItemsDialog: ({ open, onClose, target, onSuccess, onPendingChange, }: DeleteItemsDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,4 +1,5 @@
 import { type ReactNode } from 'react';
+import { type ItemLocations } from '../../../../utils/itemLocations';
 interface AssetsDndContextValue {
     isInternalDragActive: boolean;
     isMovePending: boolean;
@@ -9,6 +10,12 @@ export declare const useAssetsDnd: () => AssetsDndContextValue;
 export declare const useAssetsDndOptional: () => AssetsDndContextValue | null;
 interface AssetsDndProviderProps {
     children: ReactNode;
+    /**
+     * Real location of every loaded row, so a multi-item drag validates against
+     * each item's own parent. Defaults to a lookup that misses everything, which
+     * falls back to the folder currently open.
+     */
+    locations?: ItemLocations;
 }
-export declare const AssetsDndProvider: ({ children }: AssetsDndProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AssetsDndProvider: ({ children, locations, }: AssetsDndProviderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,9 +1,22 @@
+import { type ItemLocations } from '../../../../utils/itemLocations';
 import { type ItemKey } from '../../utils/selection';
 import type { DragItemData } from '../../../../types/dnd';
 export interface DragSet {
     items: DragItemData[];
     /** True when the active item was already selected — membership is the full selection. */
     fromSelection: boolean;
+    /**
+     * Location of the row the user actually grabbed — the only item in the set
+     * whose origin the user can point at. Names the source in the success toast.
+     */
+    activeSourceFolderId: number | null;
+    /**
+     * True when the set spans more than one source folder, which a global search
+     * selection can. There is then no single source to name, so the toast has to
+     * drop it rather than pick one item's folder and imply the others came from
+     * there too.
+     */
+    spansMultipleSources: boolean;
 }
 /**
  * Derive the drag payload once at drag start.
@@ -11,7 +24,9 @@ export interface DragSet {
  * - Dragging a selected item moves the complete current selection.
  * - Dragging an unselected item moves only that item.
  *
- * Selection is page-scoped to the current folder, so every item is stamped with
- * `currentFolderId` as its location for move validation.
+ * The active item carries its own location on `dragData` (the row it was
+ * grabbed from); the rest of the selection is resolved through `locations`.
+ * Neither is derived from the folder currently open, because search results are
+ * global — see `utils/itemLocations.ts`.
  */
-export declare const buildDragSet: (activeData: DragItemData, selectedKeys: Set<ItemKey> | undefined, currentFolderId: number | null) => DragSet;
+export declare const buildDragSet: (activeData: DragItemData, selectedKeys: Set<ItemKey> | undefined, locations: ItemLocations, fallbackFolderId: number | null) => DragSet;

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

@@ -1,4 +1,4 @@
-import type { DragFolderData } from '../../../../types/dnd';
+import type { DragFileData, DragFolderData } from '../../../../types/dnd';
 export declare const useFileDraggable: (asset: {
     id: number;
     name: string;
@@ -6,6 +6,7 @@ export declare const useFileDraggable: (asset: {
         id?: number;
     } | null;
 }) => {
+    dragData: DragFileData;
     active: import("@dnd-kit/core").Active | null;
     activatorEvent: Event | null;
     activeNodeRect: import("@dnd-kit/core").ClientRect | null;

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

@@ -1,6 +1,8 @@
 import { type ListFilters } from '../hooks/useListFilters';
 interface FilterBadgesProps {
     listFilters: ListFilters;
+    /** Sticky header is scrolled/compact — reduce the space above the badges. */
+    compact?: boolean;
 }
-export declare const FilterBadges: ({ listFilters }: FilterBadgesProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const FilterBadges: ({ listFilters, compact }: FilterBadgesProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -17,6 +17,10 @@ interface FilterMenuProps {
  * - Creation date / Last modified → preset list (single pick, `within the
  *   last` by default) + "Select date range" (creation date only) opening the
  *   range calendar; a completed range adds an `is` range badge.
+ *
+ * Closing behaviour follows how many values a field can hold: a date is one
+ * value, so picking a preset (or committing a range) closes the menu; Type is a
+ * set, so it stays open until dismissed.
  */
 export declare const FilterMenu: ({ listFilters }: FilterMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,20 @@
+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 clears the whole selection: 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, so it deliberately keeps the selection.
+ */
+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/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/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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}