@strapi/upload 5.51.0 → 5.51.2

package/dist/admin/shared/constants.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Constants shared by the upload server and the admin panel.
+ *
+ * The server stays authoritative — it validates and rejects — but the admin
+ * needs the same values to disable actions up front rather than letting the
+ * user discover a limit through a failed request.
+ */ /**
+ * Image formats the AI metadata provider can read.
+ *
+ * Anything outside this list (non-images, but also exotic image formats like
+ * SVG or TIFF) is reported as `skipped` instead of being sent.
+ *
+ * @see https://ai.google.dev/gemini-api/docs/image-understanding
+ */ const AI_METADATA_SUPPORTED_IMAGE_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/heic',
+    'image/heif'
+];
+/**
+ * Whether the AI metadata provider can generate metadata for this mime type.
+ */ const isAIMetadataSupportedMime = (mime)=>AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime);
+/**
+ * Number of images sent to the AI server per request when generating metadata
+ * for an explicit selection. Matches the URL cap of the bulk URL upload flow.
+ */ const AI_METADATA_CHUNK_SIZE = 20;
+/**
+ * Upper bound on a single synchronous AI metadata request.
+ *
+ * The selection is processed in sequential chunks inside one HTTP request, so
+ * an unbounded selection means an unbounded request — long past most proxy and
+ * load balancer timeouts, with no way for the client to learn what was written.
+ * Rejecting with a 400 lets the UI ask for a smaller selection instead.
+ */ const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;
+
+exports.AI_METADATA_CHUNK_SIZE = AI_METADATA_CHUNK_SIZE;
+exports.AI_METADATA_MAX_FILES = AI_METADATA_MAX_FILES;
+exports.AI_METADATA_SUPPORTED_IMAGE_TYPES = AI_METADATA_SUPPORTED_IMAGE_TYPES;
+exports.isAIMetadataSupportedMime = isAIMetadataSupportedMime;
+//# sourceMappingURL=constants.js.map

package/dist/admin/shared/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../shared/constants.ts"],"sourcesContent":["/**\n * Constants shared by the upload server and the admin panel.\n *\n * The server stays authoritative — it validates and rejects — but the admin\n * needs the same values to disable actions up front rather than letting the\n * user discover a limit through a failed request.\n */\n\n/**\n * Image formats the AI metadata provider can read.\n *\n * Anything outside this list (non-images, but also exotic image formats like\n * SVG or TIFF) is reported as `skipped` instead of being sent.\n *\n * @see https://ai.google.dev/gemini-api/docs/image-understanding\n */\nexport const AI_METADATA_SUPPORTED_IMAGE_TYPES = [\n  'image/png',\n  'image/jpeg',\n  'image/webp',\n  'image/heic',\n  'image/heif',\n] as const;\n\nexport type AIMetadataSupportedImageType = (typeof AI_METADATA_SUPPORTED_IMAGE_TYPES)[number];\n\n/**\n * Whether the AI metadata provider can generate metadata for this mime type.\n */\nexport const isAIMetadataSupportedMime = (mime?: string | null): boolean =>\n  AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime as AIMetadataSupportedImageType);\n\n/**\n * Number of images sent to the AI server per request when generating metadata\n * for an explicit selection. Matches the URL cap of the bulk URL upload flow.\n */\nexport const AI_METADATA_CHUNK_SIZE = 20;\n\n/**\n * Upper bound on a single synchronous AI metadata request.\n *\n * The selection is processed in sequential chunks inside one HTTP request, so\n * an unbounded selection means an unbounded request — long past most proxy and\n * load balancer timeouts, with no way for the client to learn what was written.\n * Rejecting with a 400 lets the UI ask for a smaller selection instead.\n */\nexport const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;\n"],"names":["AI_METADATA_SUPPORTED_IMAGE_TYPES","isAIMetadataSupportedMime","mime","includes","AI_METADATA_CHUNK_SIZE","AI_METADATA_MAX_FILES"],"mappings":";;AAAA;;;;;;;;;;;;;UAgBaA,iCAAAA,GAAoC;AAC/C,IAAA,WAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA;;AAKF;;UAGaC,yBAAAA,GAA4B,CAACC,OACxCF,iCAAAA,CAAkCG,QAAQ,CAACD,IAAAA;AAE7C;;;IAIO,MAAME,sBAAAA,GAAyB;AAEtC;;;;;;;AAOC,IACM,MAAMC,qBAAAA,GAAwBD,sBAAAA,GAAyB;;;;;;;"}

package/dist/admin/shared/constants.mjs

@@ -0,0 +1,38 @@
+/**
+ * Constants shared by the upload server and the admin panel.
+ *
+ * The server stays authoritative — it validates and rejects — but the admin
+ * needs the same values to disable actions up front rather than letting the
+ * user discover a limit through a failed request.
+ */ /**
+ * Image formats the AI metadata provider can read.
+ *
+ * Anything outside this list (non-images, but also exotic image formats like
+ * SVG or TIFF) is reported as `skipped` instead of being sent.
+ *
+ * @see https://ai.google.dev/gemini-api/docs/image-understanding
+ */ const AI_METADATA_SUPPORTED_IMAGE_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/heic',
+    'image/heif'
+];
+/**
+ * Whether the AI metadata provider can generate metadata for this mime type.
+ */ const isAIMetadataSupportedMime = (mime)=>AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime);
+/**
+ * Number of images sent to the AI server per request when generating metadata
+ * for an explicit selection. Matches the URL cap of the bulk URL upload flow.
+ */ const AI_METADATA_CHUNK_SIZE = 20;
+/**
+ * Upper bound on a single synchronous AI metadata request.
+ *
+ * The selection is processed in sequential chunks inside one HTTP request, so
+ * an unbounded selection means an unbounded request — long past most proxy and
+ * load balancer timeouts, with no way for the client to learn what was written.
+ * Rejecting with a 400 lets the UI ask for a smaller selection instead.
+ */ const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;
+
+export { AI_METADATA_CHUNK_SIZE, AI_METADATA_MAX_FILES, AI_METADATA_SUPPORTED_IMAGE_TYPES, isAIMetadataSupportedMime };
+//# sourceMappingURL=constants.mjs.map

package/dist/admin/shared/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","sources":["../../../shared/constants.ts"],"sourcesContent":["/**\n * Constants shared by the upload server and the admin panel.\n *\n * The server stays authoritative — it validates and rejects — but the admin\n * needs the same values to disable actions up front rather than letting the\n * user discover a limit through a failed request.\n */\n\n/**\n * Image formats the AI metadata provider can read.\n *\n * Anything outside this list (non-images, but also exotic image formats like\n * SVG or TIFF) is reported as `skipped` instead of being sent.\n *\n * @see https://ai.google.dev/gemini-api/docs/image-understanding\n */\nexport const AI_METADATA_SUPPORTED_IMAGE_TYPES = [\n  'image/png',\n  'image/jpeg',\n  'image/webp',\n  'image/heic',\n  'image/heif',\n] as const;\n\nexport type AIMetadataSupportedImageType = (typeof AI_METADATA_SUPPORTED_IMAGE_TYPES)[number];\n\n/**\n * Whether the AI metadata provider can generate metadata for this mime type.\n */\nexport const isAIMetadataSupportedMime = (mime?: string | null): boolean =>\n  AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime as AIMetadataSupportedImageType);\n\n/**\n * Number of images sent to the AI server per request when generating metadata\n * for an explicit selection. Matches the URL cap of the bulk URL upload flow.\n */\nexport const AI_METADATA_CHUNK_SIZE = 20;\n\n/**\n * Upper bound on a single synchronous AI metadata request.\n *\n * The selection is processed in sequential chunks inside one HTTP request, so\n * an unbounded selection means an unbounded request — long past most proxy and\n * load balancer timeouts, with no way for the client to learn what was written.\n * Rejecting with a 400 lets the UI ask for a smaller selection instead.\n */\nexport const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;\n"],"names":["AI_METADATA_SUPPORTED_IMAGE_TYPES","isAIMetadataSupportedMime","mime","includes","AI_METADATA_CHUNK_SIZE","AI_METADATA_MAX_FILES"],"mappings":"AAAA;;;;;;;;;;;;;UAgBaA,iCAAAA,GAAoC;AAC/C,IAAA,WAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA;;AAKF;;UAGaC,yBAAAA,GAA4B,CAACC,OACxCF,iCAAAA,CAAkCG,QAAQ,CAACD,IAAAA;AAE7C;;;IAIO,MAAME,sBAAAA,GAAyB;AAEtC;;;;;;;AAOC,IACM,MAAMC,qBAAAA,GAAwBD,sBAAAA,GAAyB;;;;"}

package/dist/admin/src/future/hooks/useMediaLibraryPermissions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * RBAC gate for the future Media Library UI. Mirrors the legacy hook of the
+ * same name: the server already enforces every action route-side (assets and
+ * folder operations share the asset permissions — folder create requires
+ * `assets.create`, folder rename/move/delete require `assets.update`); this
+ * hook is what keeps the UI honest so users don't discover a missing
+ * permission through a 403.
+ *
+ * - `canCreate` — upload (files, from URL) and New folder
+ * - `canUpdate` — edit details, replace, crop, move (dnd + bulk), delete
+ *   (single + bulk), AI metadata — the `assets.update` action covers
+ *   "Update (crop, details, replace) + delete" by definition
+ * - `canDownload` / `canCopyLink` — the matching drawer actions
+ */
+export declare const useMediaLibraryPermissions: () => {
+    isLoading: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDownload: boolean;
+    canCopyLink: boolean;
+};

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

@@ -5,6 +5,12 @@ interface AssetCropEditorProps {
     onClose: () => void;
     onApply: (file: globalThis.File, focalPoint: FocalPoint) => void;
     onSaveAsCopy: (file: globalThis.File, focalPoint: FocalPoint) => void;
+    /**
+     * "Save as copy" creates a new asset (`assets.create`), a different permission
+     * from cropping in place (`assets.update`). Hidden when the user lacks it, so
+     * an update-only role can't trigger a 403.
+     */
+    canSaveAsCopy: boolean;
 }
-export declare const AssetCropEditor: ({ asset, isBusy, onClose, onApply, onSaveAsCopy, }: AssetCropEditorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AssetCropEditor: ({ asset, isBusy, onClose, onApply, onSaveAsCopy, canSaveAsCopy, }: AssetCropEditorProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Keyword search over the whole Media Library. Owns the typing state and the
+ * debounce; `useAssetSearch` owns the `?_q=` URL param.
+ */
+export declare const AssetsSearchInput: () => import("react/jsx-runtime").JSX.Element;

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

@@ -1,9 +1,15 @@
+import { type MixedItem } from '../utils/mergeMixedList';
 import type { File } from '../../../../../../shared/contracts/files';
 import type { Folder } from '../../../../../../shared/contracts/folders';
 interface AssetsTableProps {
     assets: File[];
     folders?: Folder[];
+    /**
+     * When set ("Folders: Mixed with files"), rows render in this interleaved
+     * order instead of folders-first. Range selection follows the same order.
+     */
+    mixedItems?: MixedItem[] | null;
     onAssetItemClick: (assetId: number) => void;
 }
-export declare const AssetsTable: ({ assets, folders, onAssetItemClick }: AssetsTableProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AssetsTable: ({ assets, folders, mixedItems, onAssetItemClick, }: AssetsTableProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -0,0 +1,14 @@
+import type { File } from '../../../../../../shared/contracts/files';
+interface BulkActionsBarProps {
+    /**
+     * The assets currently rendered in the list, used to resolve the mime types
+     * of the selection — the bar needs them to know which selected assets the AI
+     * provider can actually read.
+     *
+     * Selection is page-scoped and cleared whenever the list identity changes, so
+     * every selected asset id is guaranteed to appear here.
+     */
+    assets?: File[];
+}
+export declare const BulkActionsBar: ({ assets }: BulkActionsBarProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,13 @@
+interface BulkMoveDialogProps {
+    open: boolean;
+    onClose: () => 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.
+ */
+export declare const BulkMoveDialog: ({ open, onClose }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+interface DateRangeCalendarProps {
+    /** `YYYY-MM-DD`, both set when editing an existing range badge. */
+    from?: string;
+    to?: string;
+    onSelect: (from: string, to: string) => void;
+}
+export declare const DateRangeCalendar: ({ from, to, onSelect }: DateRangeCalendarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -2,6 +2,8 @@ import { type ReactNode } from 'react';
 interface AssetsDndContextValue {
     isInternalDragActive: boolean;
     isMovePending: boolean;
+    /** O(1) lookup of whether the current drag set may drop on this destination. */
+    isValidDropTarget: (targetFolderId: number | null) => boolean;
 }
 export declare const useAssetsDnd: () => AssetsDndContextValue;
 export declare const useAssetsDndOptional: () => AssetsDndContextValue | null;

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

@@ -1,6 +1,6 @@
 import type { DragItemData } from '../../../../types/dnd';
 interface DragOverlayChipProps {
-    item: DragItemData;
+    items: DragItemData[];
 }
-export declare const DragOverlayChip: ({ item }: DragOverlayChipProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DragOverlayChip: ({ items }: DragOverlayChipProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -0,0 +1,17 @@
+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;
+}
+/**
+ * Derive the drag payload once at drag start.
+ *
+ * - 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.
+ */
+export declare const buildDragSet: (activeData: DragItemData, selectedKeys: Set<ItemKey> | undefined, currentFolderId: number | null) => DragSet;

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

@@ -0,0 +1,7 @@
+import type { FolderNode } from '../../../../../../../shared/contracts/folders';
+import type { DragItemData } from '../../../../types/dnd';
+/**
+ * Evaluate destination validity once for the full drag set. Callers look up
+ * targets in O(1) via {@link Set.has} — `null` represents the Home/root drop.
+ */
+export declare const computeValidDropTargets: (items: DragItemData[], folderStructure: FolderNode[]) => Set<number | null>;

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

@@ -2,3 +2,6 @@ export declare const toFileDraggableId: (id: number) => `file:${number}`;
 export declare const toFolderDraggableId: (id: number) => `folder:${number}`;
 export declare const toFolderTargetId: (id: number) => `folder-target:${number}`;
 export declare const parseFolderTargetId: (dndId: string | number) => number | null;
+export declare const toFolderTreeTargetId: (id: number) => `folder-tree-target:${number}`;
+export declare const HOME_TREE_TARGET_ID: "folder-tree-target:home";
+export declare const parseFolderTreeTargetId: (dndId: string | number) => number | "root" | null;

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

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

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

@@ -0,0 +1,19 @@
+export declare const useFolderTreeDroppable: (target: {
+    id: number;
+    name: string;
+} | {
+    id: null;
+    name: string;
+}) => {
+    droppable: {
+        active: import("@dnd-kit/core").Active | null;
+        rect: import("react").MutableRefObject<import("@dnd-kit/core").ClientRect | null>;
+        isOver: boolean;
+        node: import("react").MutableRefObject<HTMLElement | null>;
+        over: import("@dnd-kit/core").Over | null;
+        setNodeRef: (element: HTMLElement | null) => void;
+    };
+    isOver: boolean;
+    showValidDropHighlight: boolean;
+    showInvalidDropCursor: boolean;
+};

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

@@ -3,8 +3,15 @@ type DropHandler = (files: File[]) => void | Promise<void>;
 interface UploadDropZoneProps {
     children: ReactNode;
     onDrop?: DropHandler;
+    /**
+     * When true, the zone never enters the dragging state and never fires
+     * `onDrop` — no overlay, no "drop here" invitation. Used to hide the whole
+     * upload affordance from users without `assets.create`, so they don't drag a
+     * file onto an inviting target that then silently discards it.
+     */
+    disabled?: boolean;
 }
-export declare const UploadDropZoneProvider: ({ children, onDrop }: UploadDropZoneProps) => import("react/jsx-runtime").JSX.Element;
+export declare const UploadDropZoneProvider: ({ children, onDrop, disabled, }: UploadDropZoneProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useUploadDropZone: () => {
     isDragging: boolean;
 };

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

@@ -1,5 +1,13 @@
 interface EmptyStateProps {
     onAddAssets: () => void;
+    /**
+     * RBAC gate — without `assets.create` the "Add assets" CTA is hidden.
+     * Required (not defaulted) so a permission gate can't silently regress to
+     * permissive when a future call site forgets to pass it.
+     */
+    canAddAssets: boolean;
+    searchQuery?: string;
+    onClearSearch?: () => void;
 }
 /**
  * Empty state for the assets list (both views) when the current folder holds
@@ -7,5 +15,14 @@ interface EmptyStateProps {
  * as New > File upload; drag-and-drop upload keeps working since the page-wide
  * drop zone wraps this component.
  */
-export declare const EmptyState: ({ onAddAssets }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EmptyState: ({ onAddAssets, canAddAssets, searchQuery, onClearSearch, }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+interface FilteredEmptyStateProps {
+    onClearFilters: () => void;
+}
+/**
+ * Empty state when active filters match nothing (including contradictory
+ * badges — allowed by design). Distinct from the no-content state: the library
+ * has items, the filters exclude them all.
+ */
+export declare const FilteredEmptyState: ({ onClearFilters }: FilteredEmptyStateProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,6 @@
+import { type ListFilters } from '../hooks/useListFilters';
+interface FilterBadgesProps {
+    listFilters: ListFilters;
+}
+export declare const FilterBadges: ({ listFilters }: FilterBadgesProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,22 @@
+import { type DateField, type DatePreset, type ListFilters, type TypeValue } from '../hooks/useListFilters';
+import type { MessageDescriptor } from 'react-intl';
+export declare const TYPE_LABELS: Record<TypeValue, MessageDescriptor>;
+export declare const PRESET_LABELS: Record<DatePreset, MessageDescriptor>;
+export declare const DATE_FIELD_LABELS: Record<DateField, MessageDescriptor>;
+/** Every panel of the filter tree shares this fixed width (design). */
+export declare const FILTER_PANEL_WIDTH = "24.2rem";
+interface FilterMenuProps {
+    listFilters: ListFilters;
+}
+/**
+ * Toolbar "Filter" dropdown. Picking anything ADDS a badge (editing happens on
+ * the badge itself, see FilterBadges):
+ *
+ * - Type → keep-open checkbox list; the badge is created/updated live with the
+ *   checked set (`is` by default, condition editable on the badge).
+ * - 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.
+ */
+export declare const FilterMenu: ({ listFilters }: FilterMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,5 +1,10 @@
 interface FolderTreeProps {
     currentFolderId: number | null;
+    /**
+     * Set to `false` while a global asset search is active: the results span the
+     * whole library, so highlighting one folder would misrepresent them.
+     * */
+    showActiveFolder?: boolean;
     onSelectFolder: (folderId: number | null) => void;
 }
 /**
@@ -7,13 +12,17 @@ interface FolderTreeProps {
  * and renders:
  *
  * 1. A "Media library" title
- * 2. A "Home" entry that clears the folder query param
- * 3. A "FOLDERS" section header
- * 4. The folder tree itself
+ * 2. A filter input that prunes the tree to matching destinations
+ * 3. A "Home" entry that clears the folder query param
+ * 4. A "FOLDERS" section header
+ * 5. The folder tree itself
+ *
+ * The filter is purely local: it never touches the URL and never affects the
+ * asset list, which has its own independent search in the content toolbar.
  *
  * Presentational with respect to routing — navigation is delegated to the parent
  * via `onSelectFolder` so the URL stays the single source of truth (see
  * `useFolderNavigation`).
  */
-export declare const FolderTree: ({ currentFolderId, onSelectFolder }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FolderTree: ({ currentFolderId, showActiveFolder, onSelectFolder, }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,16 @@
+import type { FolderNode } from '../../../../../../../shared/contracts/folders';
+interface FilterFolderTreeResult {
+    nodes: FolderNode[];
+    /**
+     * Ancestors of a match, which have to be expanded for the match to be
+     * reachable.
+     */
+    expandedIds: number[];
+}
+/**
+ * Prunes the folder tree to nodes that match, or that have a matching
+ * descendant, so a match deep in the hierarchy stays reachable with its ancestor
+ * chain intact.
+ */
+export declare const filterFolderTree: (nodes: FolderNode[], matches: (name: string) => boolean) => FilterFolderTreeResult;
+export {};

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

@@ -0,0 +1,6 @@
+export declare const SPRING_LOAD_DELAY_MS = 600;
+export declare const useSpringLoadedExpand: ({ isOver, canExpand, onExpand, }: {
+    isOver: boolean;
+    canExpand: boolean;
+    onExpand: () => void;
+}) => void;

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

@@ -0,0 +1,23 @@
+import { type ListSort } from '../hooks/useListSort';
+interface SortMenuProps {
+    sort: ListSort;
+    /**
+     * The grid view forces folders on top (mixing folder cards with asset cards
+     * is not supported there), so it hides the Folders group entirely.
+     */
+    showFoldersGroup?: boolean;
+}
+/**
+ * Toolbar "Sort" dropdown: single-select sections (Sort / Folders). Picking an
+ * option keeps the menu open (`onSelect` preventDefault) so several facets can
+ * be tuned in one visit; clicking a checked facet clears it (the hook
+ * guarantees at least one sort rule stays active).
+ *
+ * Each section is single-select, so its items are radios: the checkmark icon is
+ * decorative, and `aria-checked` is what assistive tech reads. The DS `Menu`
+ * exposes no `RadioItem`, but `Menu.Item` forwards extra props onto the element
+ * it renders through Radix's `asChild`, where they take precedence over Radix's
+ * own `role="menuitem"`.
+ */
+export declare const SortMenu: ({ sort, showFoldersGroup }: SortMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * Reads and writes the global asset search term held in `?_q=`.
+ *
+ * Debouncing is the input component's job (see `AssetsSearchInput`) — this hook
+ * is a thin URL accessor so every consumer reads the same source of truth.
+ */
+export declare const useAssetSearch: () => {
+    searchQuery: string;
+    isSearching: boolean;
+    setSearchQuery: (value: string) => void;
+    clearSearch: () => void;
+};

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

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import { type ItemKey } from '../utils/selection';
+/**
+ * Ephemeral, view-state-only multi-select for the future Media Library. Selection
+ * is page-scoped and reset on folder navigation or sort/filter changes (the
+ * table/grid toggle keeps it — same list, different presentation).
+ *
+ * The actual computation lives in `../utils/selection.ts` (pure + unit-tested);
+ * this hook is a thin React wrapper. Assets and folders share one mechanism —
+ * items are tracked as namespaced keys (`asset:1` / `folder:1`) so toggle, range
+ * and select-all behave the same for both. Range / select-all receive the
+ * ordered key array from the caller (the view owns the rendered order), keeping
+ * the context data-source-agnostic.
+ */
+export interface AssetSelection {
+    /** Every selected item key (assets and folders), render-order agnostic. */
+    selectedKeys: Set<ItemKey>;
+    /** Selected asset ids, derived from {@link selectedKeys}. */
+    selectedIds: Set<number>;
+    /** Selected folder ids, derived from {@link selectedKeys}. */
+    selectedFolderIds: Set<number>;
+    anchorKey: ItemKey | null;
+    isSelected: (key: ItemKey) => boolean;
+    /** Additive toggle (Cmd/Ctrl+click, item checkbox). */
+    toggle: (key: ItemKey) => void;
+    /** Shift+click — selects the contiguous range from the anchor to the target. */
+    selectRange: (orderedKeys: ItemKey[], targetKey: ItemKey) => void;
+    /** Header checkbox — selects every rendered item (folders and assets). */
+    selectAll: (orderedKeys: ItemKey[]) => void;
+    /** Close button / folder navigation / list-identity changes. */
+    clear: () => void;
+}
+interface AssetSelectionProviderProps {
+    children: ReactNode;
+    /**
+     * When true, selection is inert: every mutator is a no-op and nothing ever
+     * reads as selected. Every bulk action is gated on `assets.update`, so a user
+     * without it has nothing to select for — the views also hide the checkboxes,
+     * and this makes the remaining paths (click-to-select, Space key) do nothing.
+     */
+    disabled?: boolean;
+}
+export declare const AssetSelectionProvider: ({ children, disabled, }: AssetSelectionProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<AssetSelection | null>>;
+export declare const useAssetSelection: () => AssetSelection;
+export declare const useAssetSelectionOptional: () => AssetSelection | null;
+export {};

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

@@ -1,12 +1,22 @@
-import type { File } from '../../../../../../shared/contracts/files';
+import type { File, Pagination } from '../../../../../../shared/contracts/files';
 declare const PAGE_SIZE = 20;
 interface UseInfiniteAssetsOptions {
     folder?: number | null;
     sort?: string;
+    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 }?: UseInfiniteAssetsOptions) => {
+declare const useInfiniteAssets: ({ folder, sort, search, filters, filtersKey, enabled, }?: UseInfiniteAssetsOptions) => {
     assets: File[];
-    pagination: import("../../../../../../shared/contracts/files").Pagination | undefined;
+    pagination: Pagination | undefined;
     isLoading: boolean;
     isFetchingMore: boolean;
     hasNextPage: boolean;

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

@@ -0,0 +1,69 @@
+/**
+ * Filter state for the assets list, backed by a single `?filters=` query param
+ * so the applied filters are shareable and survive Back/refresh.
+ *
+ * Serialized grammar — badges separated by `;`, one badge is
+ * `<field>:<condition>:<value>`:
+ *
+ * - `type:is:picture,audio` / `type:not:folder`
+ * - `created:within:1week` / `updated:notwithin:3months` / `created:exact:1day`
+ * - `created:rangeis:2024-01-01..2024-04-07` / `created:rangenot:...`
+ *
+ * Relative presets stay relative in the URL on purpose: the badge label
+ * ("1 week ago") remains truthful forever and a shared link means "within the
+ * last week from whenever it is opened". Resolution to absolute timestamps
+ * happens at query-build time (see utils/buildAssetFilters.ts).
+ *
+ * Several badges for the same field are allowed, even contradictory ones —
+ * everything is combined with AND; contradictions simply produce the filtered
+ * empty state.
+ */
+export declare const TYPE_VALUES: readonly ["folder", "picture", "audio", "video", "document"];
+export type TypeValue = (typeof TYPE_VALUES)[number];
+export declare const DATE_PRESETS: readonly ["1day", "3days", "1week", "1month", "3months", "6months", "1year"];
+export type DatePreset = (typeof DATE_PRESETS)[number];
+export type TypeCondition = 'is' | 'isNot';
+export type PresetCondition = 'isExactly' | 'withinLast' | 'notWithinLast';
+export type RangeCondition = 'is' | 'isNot';
+export type DateField = 'createdAt' | 'updatedAt';
+export interface TypeFilter {
+    kind: 'type';
+    condition: TypeCondition;
+    values: TypeValue[];
+}
+export interface DatePresetFilter {
+    kind: 'date';
+    field: DateField;
+    mode: 'preset';
+    condition: PresetCondition;
+    preset: DatePreset;
+}
+export interface DateRangeFilter {
+    kind: 'date';
+    field: DateField;
+    mode: 'range';
+    condition: RangeCondition;
+    /** Calendar dates, `YYYY-MM-DD`, inclusive on both ends. */
+    from: string;
+    to: string;
+}
+export type DateFilter = DatePresetFilter | DateRangeFilter;
+export type ListFilter = TypeFilter | DateFilter;
+/**
+ * `unknown` on purpose: the query string is user-editable, and qs parses
+ * shapes like `?filters[]=a&filters[]=b` into arrays — the guard is what
+ * makes the caller's `?filters=` type an assertion rather than a crash.
+ */
+export declare const parseFiltersParam: (raw: unknown) => ListFilter[];
+export declare const serializeFilters: (filters: ListFilter[]) => string;
+export interface ListFilters {
+    filters: ListFilter[];
+    /** Serialized form — stable fingerprint for list-identity (selection reset). */
+    serialized: string;
+    addFilter: (filter: ListFilter) => void;
+    /** Replaces the badge at `index` (condition or value edited in place). */
+    updateFilter: (index: number, filter: ListFilter) => void;
+    removeFilter: (index: number) => void;
+    clearFilters: () => void;
+}
+export declare const useListFilters: () => ListFilters;