@orthacms/media-admin 0.0.0-reserve.0

package/dist/lib/utils/assetGradient/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derives a stable, pleasant two-stop CSS gradient from an asset id. Used as a
+ * self-contained stand-in thumbnail so the mockup needs no real image files or
+ * network — the same id always yields the same gradient, so tiles stay stable
+ * across renders. Presentation-only.
+ */
+export declare function assetGradient(id: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/assetGradient/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/assetGradient/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAShD"}

package/dist/lib/utils/assetGradient/index.js

@@ -0,0 +1,16 @@
+/**
+ * Derives a stable, pleasant two-stop CSS gradient from an asset id. Used as a
+ * self-contained stand-in thumbnail so the mockup needs no real image files or
+ * network — the same id always yields the same gradient, so tiles stay stable
+ * across renders. Presentation-only.
+ */
+export function assetGradient(id) {
+    // A small FNV-ish hash so the hue is deterministic per id.
+    let hash = 0;
+    for (let i = 0; i < id.length; i += 1) {
+        hash = (hash * 31 + id.charCodeAt(i)) >>> 0;
+    }
+    const hue = hash % 360;
+    const hue2 = (hue + 40) % 360;
+    return `linear-gradient(135deg, hsl(${hue} 70% 62%), hsl(${hue2} 68% 48%))`;
+}

package/dist/lib/utils/assetHandlers/index.d.ts

@@ -0,0 +1,11 @@
+import type { AssetActionHandlers, AssetActionKind } from '../../components/AssetActionsMenu';
+import type { MediaAsset } from '../../types/mediaAsset';
+/**
+ * Adapts a single `(kind, asset)` dispatcher into the discrete
+ * {@link AssetActionHandlers} the menu expects. Lets the grid tile and the
+ * detail drawer forward every asset action to one page-level handler instead of
+ * drilling six callbacks each. `'open'` is not among them — it isn't a menu
+ * item; the tile's thumbnail and filename dispatch it directly.
+ */
+export declare function buildAssetHandlers(asset: MediaAsset, onAction: (kind: AssetActionKind, asset: MediaAsset) => void): AssetActionHandlers;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/assetHandlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/assetHandlers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,mBAAmB,EACnB,eAAe,EAClB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,GAC7D,mBAAmB,CASrB"}

package/dist/lib/utils/assetHandlers/index.js

@@ -0,0 +1,17 @@
+/**
+ * Adapts a single `(kind, asset)` dispatcher into the discrete
+ * {@link AssetActionHandlers} the menu expects. Lets the grid tile and the
+ * detail drawer forward every asset action to one page-level handler instead of
+ * drilling six callbacks each. `'open'` is not among them — it isn't a menu
+ * item; the tile's thumbnail and filename dispatch it directly.
+ */
+export function buildAssetHandlers(asset, onAction) {
+    return {
+        onDownload: () => onAction('download', asset),
+        onCopyLink: () => onAction('copyLink', asset),
+        onDuplicate: () => onAction('duplicate', asset),
+        onRename: () => onAction('rename', asset),
+        onMove: () => onAction('move', asset),
+        onDelete: () => onAction('delete', asset)
+    };
+}

package/dist/lib/utils/folderContents/index.d.ts

@@ -0,0 +1,17 @@
+import type { MediaFolder } from '../../types/mediaFolder';
+/** What a folder holds, counted through its whole subtree. */
+export type FolderContents = {
+    /** Descendant folders (the folder itself excluded). */
+    folders: number;
+    /** Assets anywhere below, including directly inside. */
+    assets: number;
+};
+/**
+ * Counts everything a folder holds, recursively — what a delete would take with
+ * it. Derived from the store's already-loaded tree (`folders` + the per-folder
+ * `folderCounts` the list endpoint returns), so naming the damage in a
+ * confirmation costs no extra request; it is as fresh as the last folders read,
+ * which every mutation invalidates.
+ */
+export declare function folderContents(folders: readonly MediaFolder[], assetCounts: ReadonlyMap<string, number>, folderId: string): FolderContents;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/folderContents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/folderContents/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,8DAA8D;AAC9D,MAAM,MAAM,cAAc,GAAG;IACzB,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC1B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,QAAQ,EAAE,MAAM,GACjB,cAAc,CA0BhB"}

package/dist/lib/utils/folderContents/index.js

@@ -0,0 +1,35 @@
+/**
+ * Counts everything a folder holds, recursively — what a delete would take with
+ * it. Derived from the store's already-loaded tree (`folders` + the per-folder
+ * `folderCounts` the list endpoint returns), so naming the damage in a
+ * confirmation costs no extra request; it is as fresh as the last folders read,
+ * which every mutation invalidates.
+ */
+export function folderContents(folders, assetCounts, folderId) {
+    const childrenOf = new Map();
+    for (const folder of folders) {
+        const siblings = childrenOf.get(folder.parentId) ?? [];
+        siblings.push(folder);
+        childrenOf.set(folder.parentId, siblings);
+    }
+    let descendants = 0;
+    let assets = assetCounts.get(folderId) ?? 0;
+    // Iterative, not recursive: a cycle in a malformed tree would otherwise
+    // blow the stack, and the visited set makes that impossible.
+    const seen = new Set([folderId]);
+    const queue = [folderId];
+    while (queue.length) {
+        const current = queue.pop();
+        if (!current)
+            break;
+        for (const child of childrenOf.get(current) ?? []) {
+            if (seen.has(child.id))
+                continue;
+            seen.add(child.id);
+            descendants += 1;
+            assets += assetCounts.get(child.id) ?? 0;
+            queue.push(child.id);
+        }
+    }
+    return { folders: descendants, assets };
+}

package/dist/lib/utils/folderTree/index.d.ts

@@ -0,0 +1,13 @@
+import type { MediaFolder } from '../../types/mediaFolder';
+/** A folder paired with its depth below the root, for indented rendering. */
+export type FolderTreeNode = {
+    folder: MediaFolder;
+    depth: number;
+};
+/**
+ * Flattens the folder forest into a depth-first, name-sorted list annotated with
+ * each folder's depth below the root. Shared by the folders nav tree and the
+ * move-to-folder picker so both render the same ordering and indentation.
+ */
+export declare function flattenFolderTree(folders: MediaFolder[], parentId?: string, depth?: number): FolderTreeNode[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/folderTree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/folderTree/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,GAAE,MAAuB,EACjC,KAAK,SAAI,GACV,cAAc,EAAE,CAQlB"}

package/dist/lib/utils/folderTree/index.js

@@ -0,0 +1,15 @@
+import { ROOT_FOLDER_ID } from '../../constants';
+/**
+ * Flattens the folder forest into a depth-first, name-sorted list annotated with
+ * each folder's depth below the root. Shared by the folders nav tree and the
+ * move-to-folder picker so both render the same ordering and indentation.
+ */
+export function flattenFolderTree(folders, parentId = ROOT_FOLDER_ID, depth = 0) {
+    return folders
+        .filter((folder) => folder.parentId === parentId)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .flatMap((folder) => [
+        { folder, depth },
+        ...flattenFolderTree(folders, folder.id, depth + 1)
+    ]);
+}

package/dist/lib/utils/formatBytes/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formats a byte count as a short human-readable size (e.g. `1.4 MB`). Uses
+ * binary units and trims a trailing `.0`. Presentation-only — safe for labels.
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/formatBytes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/formatBytes/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYjD"}

package/dist/lib/utils/formatBytes/index.js

@@ -0,0 +1,17 @@
+/**
+ * Formats a byte count as a short human-readable size (e.g. `1.4 MB`). Uses
+ * binary units and trims a trailing `.0`. Presentation-only — safe for labels.
+ */
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    const rounded = value >= 10 ? Math.round(value) : Math.round(value * 10) / 10;
+    return `${rounded} ${units[unit]}`;
+}

package/dist/lib/utils/formatDuration/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formats a duration in seconds as `m:ss` (or `h:mm:ss` past an hour), for the
+ * playback length shown on audio/video assets. Presentation-only.
+ */
+export declare function formatDuration(seconds: number): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/formatDuration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/formatDuration/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQtD"}

package/dist/lib/utils/formatDuration/index.js

@@ -0,0 +1,13 @@
+/**
+ * Formats a duration in seconds as `m:ss` (or `h:mm:ss` past an hour), for the
+ * playback length shown on audio/video assets. Presentation-only.
+ */
+export function formatDuration(seconds) {
+    const hrs = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const pad = (n) => n.toString().padStart(2, '0');
+    return hrs > 0
+        ? `${hrs}:${pad(mins)}:${pad(secs)}`
+        : `${mins}:${pad(secs)}`;
+}

package/dist/lib/utils/kindFromMime/index.d.ts

@@ -0,0 +1,10 @@
+import { type MediaKind } from '../../constants';
+/**
+ * The coarse {@link MediaKind} for a MIME type. A **local, deliberately rough**
+ * classification for a file that hasn't been uploaded yet (a staged upload's
+ * preview tile) — the server owns the real one, and it's the server's `kind`
+ * that ends up on the asset. Unknown types read as a document, which is what the
+ * glyph fallback should be anyway.
+ */
+export declare function kindFromMime(mimeType: string): MediaKind;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/kindFromMime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/kindFromMime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAW7D;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAMxD"}

package/dist/lib/utils/kindFromMime/index.js

@@ -0,0 +1,27 @@
+import { MEDIA_KIND } from '../../constants';
+/** MIME types the library counts as an archive. */
+const ARCHIVE_TYPES = [
+    'application/zip',
+    'application/x-tar',
+    'application/gzip',
+    'application/x-7z-compressed',
+    'application/vnd.rar'
+];
+/**
+ * The coarse {@link MediaKind} for a MIME type. A **local, deliberately rough**
+ * classification for a file that hasn't been uploaded yet (a staged upload's
+ * preview tile) — the server owns the real one, and it's the server's `kind`
+ * that ends up on the asset. Unknown types read as a document, which is what the
+ * glyph fallback should be anyway.
+ */
+export function kindFromMime(mimeType) {
+    if (mimeType.startsWith('image/'))
+        return MEDIA_KIND.Image;
+    if (mimeType.startsWith('video/'))
+        return MEDIA_KIND.Video;
+    if (mimeType.startsWith('audio/'))
+        return MEDIA_KIND.Audio;
+    if (ARCHIVE_TYPES.includes(mimeType))
+        return MEDIA_KIND.Archive;
+    return MEDIA_KIND.Document;
+}

package/dist/lib/utils/mediaAccept/index.d.ts

@@ -0,0 +1,30 @@
+import type { MediaAsset } from '../../types/mediaAsset';
+/** A media field's accepted-asset restriction (mirrors the server's `accept`). */
+export type MediaAccept = {
+    kinds?: readonly string[];
+    mimeTypes?: readonly string[];
+};
+/**
+ * Whether an asset satisfies a media field's `accept` — the admin mirror of the
+ * server's `acceptsAsset`, used to pre-filter the picker's candidates so a user
+ * can't select a disallowed asset (the server still enforces it on save). An
+ * absent restriction, or one with neither list, accepts anything.
+ */
+export declare function acceptsAsset(accept: MediaAccept | undefined, asset: Pick<MediaAsset, 'kind' | 'mimeType'>): boolean;
+/**
+ * Whether a **local file** satisfies a media field's `accept`, judged from its
+ * MIME type before it is uploaded — so a file staged on a field is checked at
+ * the moment it's chosen rather than after the save uploads it. The kind is the
+ * rough local classification ({@link kindFromMime}); the server re-checks the
+ * real asset on save, which is the enforcing pass.
+ */
+export declare function acceptsFile(accept: MediaAccept | undefined, file: File): boolean;
+/**
+ * The single coarse `kind` an `accept` allows, when it names exactly one and no
+ * MIME list — so the picker can seed the server's `?kind=` filter. Otherwise
+ * `undefined` (no server-side narrowing; filtered client-side).
+ */
+export declare function singleAcceptKind(accept: MediaAccept | undefined): string | undefined;
+/** A short human description of what a field accepts, for the empty-state hint. */
+export declare function describeAccept(accept: MediaAccept | undefined): string | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/mediaAccept/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/mediaAccept/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,kFAAkF;AAClF,MAAM,MAAM,WAAW,GAAG;IACtB,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,CAAC;AAUF;;;;;GAKG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAC,GAC7C,OAAO,CAQT;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,IAAI,EAAE,IAAI,GACX,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,WAAW,GAAG,SAAS,GAChC,MAAM,GAAG,SAAS,CAKpB;AAED,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAM7E"}

package/dist/lib/utils/mediaAccept/index.js

@@ -0,0 +1,63 @@
+import { kindFromMime } from '../kindFromMime';
+/** A MIME pattern matches a concrete MIME exactly or as a `type/*` glob. */
+function mimeMatches(pattern, mimeType) {
+    if (pattern === mimeType)
+        return true;
+    if (pattern.endsWith('/*'))
+        return mimeType.startsWith(pattern.slice(0, -1));
+    return false;
+}
+/**
+ * Whether an asset satisfies a media field's `accept` — the admin mirror of the
+ * server's `acceptsAsset`, used to pre-filter the picker's candidates so a user
+ * can't select a disallowed asset (the server still enforces it on save). An
+ * absent restriction, or one with neither list, accepts anything.
+ */
+export function acceptsAsset(accept, asset) {
+    if (!accept)
+        return true;
+    const kinds = accept.kinds ?? [];
+    const mimeTypes = accept.mimeTypes ?? [];
+    if (!kinds.length && !mimeTypes.length)
+        return true;
+    if (kinds.includes(asset.kind))
+        return true;
+    if (mimeTypes.some((p) => mimeMatches(p, asset.mimeType)))
+        return true;
+    return false;
+}
+/**
+ * Whether a **local file** satisfies a media field's `accept`, judged from its
+ * MIME type before it is uploaded — so a file staged on a field is checked at
+ * the moment it's chosen rather than after the save uploads it. The kind is the
+ * rough local classification ({@link kindFromMime}); the server re-checks the
+ * real asset on save, which is the enforcing pass.
+ */
+export function acceptsFile(accept, file) {
+    return acceptsAsset(accept, {
+        kind: kindFromMime(file.type),
+        mimeType: file.type
+    });
+}
+/**
+ * The single coarse `kind` an `accept` allows, when it names exactly one and no
+ * MIME list — so the picker can seed the server's `?kind=` filter. Otherwise
+ * `undefined` (no server-side narrowing; filtered client-side).
+ */
+export function singleAcceptKind(accept) {
+    if (accept && !accept.mimeTypes?.length && accept.kinds?.length === 1) {
+        return accept.kinds[0];
+    }
+    return undefined;
+}
+/** A short human description of what a field accepts, for the empty-state hint. */
+export function describeAccept(accept) {
+    if (!accept)
+        return null;
+    const parts = [];
+    if (accept.kinds?.length)
+        parts.push(accept.kinds.join(' / '));
+    if (accept.mimeTypes?.length)
+        parts.push(accept.mimeTypes.join(' / '));
+    return parts.length ? parts.join(', ') : null;
+}

package/dist/lib/utils/mediaPlugin/index.d.ts

@@ -0,0 +1,15 @@
+import type { AdminPlugin } from '@orthacms/bootstrap-admin';
+/**
+ * Admin-side media plugin shape. A thin alias of {@link AdminPlugin}, kept named
+ * so future config has a home.
+ */
+export type MediaAdminPlugin = AdminPlugin;
+/**
+ * Creates the admin-side Media Library plugin. It lives **strictly inside a
+ * workspace**: it contributes no top-level route and no top-toolbar nav entry,
+ * only a rail button (`order: 20`) + a route to the workspace shell's slots
+ * (owned by `@orthacms/workspaces-admin`). Register it after
+ * `WorkspacesPlugin()` so those slots exist.
+ */
+export declare function MediaPlugin(): MediaAdminPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/mediaPlugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/mediaPlugin/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA6C7D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAqJ9C"}

package/dist/lib/utils/mediaPlugin/index.js

@@ -0,0 +1,177 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy } from 'react';
+import { WORKSPACE_ROUTE_SLOT, WORKSPACE_NAV_SLOT } from '@orthacms/workspaces-admin';
+import { CONTENT_FIELD_TYPE, ENTRY_PRESAVE_SLOT, ENTRY_TAB, ENTRY_TAB_SLOT } from '@orthacms/content-admin';
+import { WYSIWYG_MEDIA_SLOT } from '@orthacms/wysiwyg-admin';
+import { INSIGHTS_SECTION_IDS, INSIGHTS_WIDGET_SLOT } from '@orthacms/insights-admin';
+import { Image, Upload } from 'lucide-react';
+import { MediaStorageStat } from '../../components/MediaStorageStat';
+import { MediaStorageWidget } from '../../components/MediaStorageWidget';
+import { MediaUploadsWidget } from '../../components/MediaUploadsWidget';
+import { MediaAltTextWidget } from '../../components/MediaAltTextWidget';
+import { EntryMediaTab } from '../../components/EntryMediaTab';
+import { MediaLibraryPageSkeleton } from '../../components/MediaLibrarySkeleton';
+import { WysiwygLibrarySource } from '../../components/WysiwygLibrarySource';
+import { WysiwygUploadSource } from '../../components/WysiwygUploadSource';
+import { MEDIA_PRESAVE_ID, usePendingMediaUploads } from '../../hooks/usePendingMediaUploads';
+import { MEDIA_READ } from '../../constants';
+const MediaLibraryPage = lazy(() => import('../../pages/MediaLibraryPage').then((module) => ({
+    default: module.MediaLibraryPage
+})));
+/** The Media tab applies to any type that declares a media field. */
+function hasMediaField(schema) {
+    return schema.fields.some((field) => field.type === CONTENT_FIELD_TYPE.Media);
+}
+/**
+ * Creates the admin-side Media Library plugin. It lives **strictly inside a
+ * workspace**: it contributes no top-level route and no top-toolbar nav entry,
+ * only a rail button (`order: 20`) + a route to the workspace shell's slots
+ * (owned by `@orthacms/workspaces-admin`). Register it after
+ * `WorkspacesPlugin()` so those slots exist.
+ */
+export function MediaPlugin() {
+    return {
+        name: 'media',
+        slots: [
+            {
+                // Insights widgets. Media owns `media_asset`, so it owns the
+                // cards reading it — the Insights plugin knows nothing about
+                // assets, kinds or bytes.
+                slot: INSIGHTS_WIDGET_SLOT,
+                items: [
+                    {
+                        id: 'insights.media.storage',
+                        section: INSIGHTS_SECTION_IDS.Overview,
+                        order: 40,
+                        size: 'xs',
+                        permission: MEDIA_READ,
+                        titleId: 'media.insights.storage.label',
+                        defaultTitle: 'Media storage',
+                        Component: MediaStorageStat
+                    },
+                    {
+                        id: 'insights.media.storageBreakdown',
+                        section: INSIGHTS_SECTION_IDS.Reach,
+                        order: 10,
+                        size: 'sm',
+                        permission: MEDIA_READ,
+                        titleId: 'media.insights.storageBreakdown.title',
+                        defaultTitle: "What's using the storage",
+                        Component: MediaStorageWidget
+                    },
+                    {
+                        id: 'insights.media.uploads',
+                        section: INSIGHTS_SECTION_IDS.Reach,
+                        order: 20,
+                        size: 'sm',
+                        permission: MEDIA_READ,
+                        titleId: 'media.insights.uploads.title',
+                        defaultTitle: 'Uploads',
+                        Component: MediaUploadsWidget
+                    },
+                    {
+                        id: 'insights.media.alt',
+                        section: INSIGHTS_SECTION_IDS.Reach,
+                        order: 30,
+                        size: 'sm',
+                        permission: MEDIA_READ,
+                        titleId: 'media.insights.alt.title',
+                        defaultTitle: 'Images missing alt text',
+                        Component: MediaAltTextWidget
+                    }
+                ]
+            },
+            {
+                slot: WORKSPACE_NAV_SLOT,
+                items: [
+                    {
+                        labelId: 'media.nav.label',
+                        defaultLabel: 'Media Library',
+                        to: 'media',
+                        order: 20,
+                        icon: Image,
+                        iconColor: 'text-nav-teal'
+                    }
+                ]
+            },
+            {
+                slot: WORKSPACE_ROUTE_SLOT,
+                items: [
+                    {
+                        path: 'media/*',
+                        element: (_jsx(Suspense, { fallback: _jsx(MediaLibraryPageSkeleton, {}), children: _jsx(MediaLibraryPage, {}) }))
+                    }
+                ]
+            },
+            // The entry editor's Media tab — rendered by content-admin's
+            // ENTRY_TAB_SLOT only when the open type has a media field, so the
+            // tab appears exactly where media applies. Its `slug` is content's
+            // own `media` tab route, already accepted by the tab router.
+            {
+                slot: ENTRY_TAB_SLOT,
+                items: [
+                    {
+                        id: 'media.entry.tab',
+                        slug: ENTRY_TAB.Media,
+                        label: {
+                            id: 'media.tab.label',
+                            defaultMessage: 'Media'
+                        },
+                        order: 10,
+                        appliesTo: hasMediaField,
+                        Component: EntryMediaTab
+                    }
+                ]
+            },
+            // Rich text gets the library too. The editor
+            // (`@orthacms/wysiwyg-admin`) declares `WYSIWYG_MEDIA_SLOT` and
+            // knows only how to *hold* an image or a video; browsing folders
+            // and uploading are this plugin's job, so it fills the seam rather
+            // than the editor importing a library it would then be pinned to.
+            //
+            // Two entries, because they are different acts: pick something that
+            // exists, or add something that doesn't. Both end with an asset in
+            // the Media Library — an image in a body is a first-class asset,
+            // not an orphan attachment.
+            {
+                slot: WYSIWYG_MEDIA_SLOT,
+                items: [
+                    {
+                        id: 'media.wysiwyg.library',
+                        label: {
+                            id: 'media.wysiwyg.library',
+                            defaultMessage: 'Media Library…'
+                        },
+                        icon: Image,
+                        order: 10,
+                        Source: WysiwygLibrarySource
+                    },
+                    {
+                        id: 'media.wysiwyg.upload',
+                        label: {
+                            id: 'media.wysiwyg.upload',
+                            defaultMessage: 'Upload files…'
+                        },
+                        icon: Upload,
+                        order: 20,
+                        Source: WysiwygUploadSource
+                    }
+                ]
+            },
+            // Files chosen on a media field are staged, not uploaded: this step
+            // runs inside the record's save and puts them in the library then,
+            // so an abandoned edit leaves no orphan assets behind. It also owns
+            // the staging state, mounted above the tab body (a route) so it
+            // survives switching tabs.
+            {
+                slot: ENTRY_PRESAVE_SLOT,
+                items: [
+                    {
+                        id: MEDIA_PRESAVE_ID,
+                        usePresave: usePendingMediaUploads
+                    }
+                ]
+            }
+        ]
+    };
+}

package/dist/lib/utils/toWysiwygEmbed/index.d.ts

@@ -0,0 +1,23 @@
+import type { WysiwygMediaEmbed } from '@orthacms/wysiwyg-admin';
+import type { MediaAsset } from '../../types/mediaAsset';
+/**
+ * A library asset as the rich-text editor's embed — the one place this plugin
+ * translates its own model into the editor's.
+ *
+ * Returns `null` for an asset the editor has no node for (audio, a PDF, a zip).
+ * The picker already filters those out; this is the second gate, so a caller
+ * that skips the filter can't put a `<img src="report.pdf">` in a body.
+ *
+ * ### Which URL
+ *
+ * An image embeds its **`previewUrl`** — the ~1280px derivative — not the
+ * original. A body rendered on a page has no use for a 12-megapixel JPEG, and
+ * the derivative is what the library generated it for. Falling back to `url`
+ * covers an SVG or a small image that got no derivative. A video always embeds
+ * `url`: there are no video derivatives, and the tag streams it.
+ *
+ * The asset's own `alt` rides along, so an author who wrote it once in the
+ * library doesn't write it again per body.
+ */
+export declare function toWysiwygEmbed(asset: MediaAsset): WysiwygMediaEmbed | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/toWysiwygEmbed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/toWysiwygEmbed/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,iBAAiB,GAAG,IAAI,CAsB1E"}

package/dist/lib/utils/toWysiwygEmbed/index.js

@@ -0,0 +1,44 @@
+import { WYSIWYG_MEDIA_KIND } from '@orthacms/wysiwyg-admin';
+import { MEDIA_KIND } from '../../constants';
+/**
+ * A library asset as the rich-text editor's embed — the one place this plugin
+ * translates its own model into the editor's.
+ *
+ * Returns `null` for an asset the editor has no node for (audio, a PDF, a zip).
+ * The picker already filters those out; this is the second gate, so a caller
+ * that skips the filter can't put a `<img src="report.pdf">` in a body.
+ *
+ * ### Which URL
+ *
+ * An image embeds its **`previewUrl`** — the ~1280px derivative — not the
+ * original. A body rendered on a page has no use for a 12-megapixel JPEG, and
+ * the derivative is what the library generated it for. Falling back to `url`
+ * covers an SVG or a small image that got no derivative. A video always embeds
+ * `url`: there are no video derivatives, and the tag streams it.
+ *
+ * The asset's own `alt` rides along, so an author who wrote it once in the
+ * library doesn't write it again per body.
+ */
+export function toWysiwygEmbed(asset) {
+    if (asset.kind === MEDIA_KIND.Image) {
+        return {
+            kind: WYSIWYG_MEDIA_KIND.Image,
+            src: asset.previewUrl || asset.url,
+            ...(asset.alt ? { alt: asset.alt } : {}),
+            // Seeds the node (and the resize handle) with the asset's own
+            // width, so it lands at its natural size rather than stretched to
+            // the column. `previewUrl` is a *scaled* derivative, so the stored
+            // dimensions overstate it — the browser scales to fit either way,
+            // and the number is only ever a starting point the author drags.
+            ...(asset.dimensions ? { width: asset.dimensions.width } : {})
+        };
+    }
+    if (asset.kind === MEDIA_KIND.Video) {
+        return {
+            kind: WYSIWYG_MEDIA_KIND.Video,
+            src: asset.url,
+            ...(asset.dimensions ? { width: asset.dimensions.width } : {})
+        };
+    }
+    return null;
+}