@pro-laico/payload-mux 0.0.0

package/dist/lib/getAssetMetadata.d.ts

@@ -0,0 +1,34 @@
+/** The fields `getAssetMetadata` reads, shared by the Mux `Asset` (from the assets API) and
+ *  the asset webhook event `data` — both satisfy this structurally, so callers pass either
+ *  without a cast. */
+export interface AssetLike {
+    playback_ids?: Array<{
+        id: string;
+        policy: 'public' | 'signed' | 'drm';
+    }> | null;
+    aspect_ratio?: string | null;
+    duration?: number | null;
+    tracks?: ReadonlyArray<{
+        type?: string;
+        max_width?: number;
+        max_height?: number;
+    }> | null;
+}
+/** The subset of the video doc derived from a ready Mux asset. The plugin tracks only the two
+ *  policies it can build URLs for; a `drm` playback id (rare) is treated as `signed`, since it
+ *  too needs a token. */
+export interface MuxAssetMetadata {
+    playbackOptions?: Array<{
+        playbackId: string;
+        playbackPolicy: 'public' | 'signed';
+    }>;
+    aspectRatio?: string;
+    duration?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+/** Map a ready Mux asset (or asset webhook payload) onto the video doc's fields: playback
+ *  ids/policies, a CSS-friendly aspect ratio (`16:9` → `16/9`), duration, and the video
+ *  track's max dimensions. */
+export declare const getAssetMetadata: (asset: AssetLike) => MuxAssetMetadata;
+//# sourceMappingURL=getAssetMetadata.d.ts.map

package/dist/lib/getAssetMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAssetMetadata.d.ts","sourceRoot":"","sources":["../../src/lib/getAssetMetadata.ts"],"names":[],"mappings":"AAAA;;sBAEsB;AACtB,MAAM,WAAW,SAAS;IACxB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAA;KAAE,CAAC,GAAG,IAAI,CAAA;IAChF,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,MAAM,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAA;CAC1F;AAED;;yBAEyB;AACzB,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,QAAQ,GAAG,QAAQ,CAAA;KAAE,CAAC,CAAA;IACpF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;8BAE8B;AAC9B,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,gBAYnD,CAAA"}

package/dist/lib/getAssetMetadata.js

@@ -0,0 +1,21 @@
+/** The fields `getAssetMetadata` reads, shared by the Mux `Asset` (from the assets API) and
+ *  the asset webhook event `data` — both satisfy this structurally, so callers pass either
+ *  without a cast. */ /** Map a ready Mux asset (or asset webhook payload) onto the video doc's fields: playback
+ *  ids/policies, a CSS-friendly aspect ratio (`16:9` → `16/9`), duration, and the video
+ *  track's max dimensions. */ export const getAssetMetadata = (asset)=>{
+    const videoTrack = asset.tracks?.find((track)=>track.type === 'video');
+    return {
+        playbackOptions: asset.playback_ids?.map((value)=>({
+                playbackId: value.id,
+                playbackPolicy: value.policy === 'public' ? 'public' : 'signed'
+            })),
+        aspectRatio: asset.aspect_ratio?.replace(':', '/'),
+        duration: asset.duration ?? undefined,
+        ...videoTrack ? {
+            maxWidth: videoTrack.max_width,
+            maxHeight: videoTrack.max_height
+        } : {}
+    };
+};
+
+//# sourceMappingURL=getAssetMetadata.js.map

package/dist/lib/getAssetMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/getAssetMetadata.ts"],"sourcesContent":["/** The fields `getAssetMetadata` reads, shared by the Mux `Asset` (from the assets API) and\n *  the asset webhook event `data` — both satisfy this structurally, so callers pass either\n *  without a cast. */\nexport interface AssetLike {\n  playback_ids?: Array<{ id: string; policy: 'public' | 'signed' | 'drm' }> | null\n  aspect_ratio?: string | null\n  duration?: number | null\n  tracks?: ReadonlyArray<{ type?: string; max_width?: number; max_height?: number }> | null\n}\n\n/** The subset of the video doc derived from a ready Mux asset. The plugin tracks only the two\n *  policies it can build URLs for; a `drm` playback id (rare) is treated as `signed`, since it\n *  too needs a token. */\nexport interface MuxAssetMetadata {\n  playbackOptions?: Array<{ playbackId: string; playbackPolicy: 'public' | 'signed' }>\n  aspectRatio?: string\n  duration?: number\n  maxWidth?: number\n  maxHeight?: number\n}\n\n/** Map a ready Mux asset (or asset webhook payload) onto the video doc's fields: playback\n *  ids/policies, a CSS-friendly aspect ratio (`16:9` → `16/9`), duration, and the video\n *  track's max dimensions. */\nexport const getAssetMetadata = (asset: AssetLike): MuxAssetMetadata => {\n  const videoTrack = asset.tracks?.find((track) => track.type === 'video')\n\n  return {\n    playbackOptions: asset.playback_ids?.map((value) => ({\n      playbackId: value.id,\n      playbackPolicy: value.policy === 'public' ? 'public' : 'signed',\n    })),\n    aspectRatio: asset.aspect_ratio?.replace(':', '/'),\n    duration: asset.duration ?? undefined,\n    ...(videoTrack ? { maxWidth: videoTrack.max_width, maxHeight: videoTrack.max_height } : {}),\n  }\n}\n"],"names":["getAssetMetadata","asset","videoTrack","tracks","find","track","type","playbackOptions","playback_ids","map","value","playbackId","id","playbackPolicy","policy","aspectRatio","aspect_ratio","replace","duration","undefined","maxWidth","max_width","maxHeight","max_height"],"mappings":"AAAA;;oBAEoB,GAmBpB;;4BAE4B,GAC5B,OAAO,MAAMA,mBAAmB,CAACC;IAC/B,MAAMC,aAAaD,MAAME,MAAM,EAAEC,KAAK,CAACC,QAAUA,MAAMC,IAAI,KAAK;IAEhE,OAAO;QACLC,iBAAiBN,MAAMO,YAAY,EAAEC,IAAI,CAACC,QAAW,CAAA;gBACnDC,YAAYD,MAAME,EAAE;gBACpBC,gBAAgBH,MAAMI,MAAM,KAAK,WAAW,WAAW;YACzD,CAAA;QACAC,aAAad,MAAMe,YAAY,EAAEC,QAAQ,KAAK;QAC9CC,UAAUjB,MAAMiB,QAAQ,IAAIC;QAC5B,GAAIjB,aAAa;YAAEkB,UAAUlB,WAAWmB,SAAS;YAAEC,WAAWpB,WAAWqB,UAAU;QAAC,IAAI,CAAC,CAAC;IAC5F;AACF,EAAC"}

package/dist/lib/ingest.d.ts

@@ -0,0 +1,53 @@
+import type Mux from '@mux/mux-node';
+import type { Payload } from 'payload';
+import type { MuxVideoNewAssetSettings } from '../types';
+/** A server-side video source: a local file path or an `http(s)` URL. */
+export type MuxSource = string;
+export interface IngestMuxAssetOptions {
+    /** Base new-asset settings — normally the plugin's `uploadSettings.new_asset_settings`, so a
+     *  server-side ingest produces the same asset config as the admin direct-upload path. */
+    newAssetSettings?: MuxVideoNewAssetSettings;
+    /** Playback policy override for this asset. When set, wins over `newAssetSettings`'s policy;
+     *  otherwise the configured policy applies (falling back to `'public'`). */
+    playbackPolicy?: 'public' | 'signed';
+    /** CORS origin for the direct upload. @default '*' */
+    corsOrigin?: string;
+}
+/**
+ * Resolve the `new_asset_settings` for an ingest, mirroring the admin path (`upload.ts`): a
+ * `['public']` default, overlaid with the plugin's configured `newAssetSettings`, with a per-call
+ * `playbackPolicy` winning last. Keeps seeded/ingested videos in sync with admin uploads.
+ */
+export declare function resolveNewAssetSettings(newAssetSettings?: MuxVideoNewAssetSettings, playbackPolicy?: 'public' | 'signed'): MuxVideoNewAssetSettings;
+/**
+ * Ingest a video into Mux server-side: create a direct upload, PUT the source bytes (from a
+ * local path or an `http(s)` URL), and poll until the asset is `ready`. The programmatic
+ * counterpart to the admin uploader's client-side direct upload — used for seeding, imports,
+ * and migrations. Returns the ready asset.
+ *
+ * `new_asset_settings` are resolved by {@link resolveNewAssetSettings} — the plugin's configured
+ * `newAssetSettings` over a `['public']` default, with `playbackPolicy` as a per-call override —
+ * so seeded videos honor the same playback policy as admin uploads.
+ */
+export declare function ingestMuxAsset(mux: Mux, source: MuxSource, opts?: IngestMuxAssetOptions): Promise<Mux.Video.Assets.Asset>;
+export interface IngestMuxVideoOptions {
+    /** Local file path or `http(s)` URL of the video to ingest. */
+    source: MuxSource;
+    /** Title for the created `mux-video` doc (must be unique within the collection). */
+    title: string;
+    /** Playback policy override for the uploaded asset. @default the plugin's configured policy */
+    playbackPolicy?: 'public' | 'signed';
+    /** Optional poster timestamp (seconds). */
+    posterTimestamp?: number;
+    /** The `mux-video` collection slug. @default 'mux-video' */
+    collection?: string;
+}
+/**
+ * Create a `mux-video` doc from a local file or URL — the programmatic equivalent of uploading
+ * through the admin uploader. Hands `source` to the collection, whose `beforeValidate` hook
+ * uploads it to Mux and folds in the ready asset's metadata.
+ */
+export declare function ingestMuxVideo(payload: Payload, opts: IngestMuxVideoOptions): Promise<{
+    id: string | number;
+}>;
+//# sourceMappingURL=ingest.d.ts.map

package/dist/lib/ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../src/lib/ingest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAkB,OAAO,EAAE,MAAM,SAAS,CAAA;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAA;AAGxD,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AA6B9B,MAAM,WAAW,qBAAqB;IACpC;6FACyF;IACzF,gBAAgB,CAAC,EAAE,wBAAwB,CAAA;IAC3C;gFAC4E;IAC5E,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACpC,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,CAAC,EAAE,wBAAwB,EAC3C,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,GACnC,wBAAwB,CAM1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,qBAA0B,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAgCnI;AAED,MAAM,WAAW,qBAAqB;IACpC,+DAA+D;IAC/D,MAAM,EAAE,SAAS,CAAA;IACjB,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAA;IACb,+FAA+F;IAC/F,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACpC,2CAA2C;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,CAWpH"}

package/dist/lib/ingest.js

@@ -0,0 +1,109 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { delay } from "./delay.js";
+/** Poll `fetch` until `done(value)` is true or the deadline passes; returns the last value. */ async function pollUntil(fetch1, done, intervalMs, timeoutMs = 120_000) {
+    const deadline = Date.now() + timeoutMs;
+    let value = await fetch1();
+    while(!done(value) && Date.now() < deadline){
+        await delay(intervalMs);
+        value = await fetch1();
+    }
+    return value;
+}
+/** Build the PUT body for the Mux upload. A local path streams from disk with a Content-Length
+ *  (so a large video never sits fully in memory); an `http(s)` URL is fetched and forwarded.
+ *  Note: a URL source is buffered fully in memory before the PUT (Mux's upload endpoint needs a
+ *  known length) — for very large remote files, download to disk and ingest the local path. */ async function buildUploadBody(source) {
+    if (/^https?:\/\//i.test(source)) {
+        const res = await fetch(source);
+        if (!res.ok) throw new Error(`[payload-mux] failed to fetch source '${source}': ${res.status} ${res.statusText}`);
+        return {
+            body: new Blob([
+                await res.arrayBuffer()
+            ])
+        };
+    }
+    const { size } = await stat(source).catch(()=>{
+        throw new Error(`[payload-mux] source file not found: ${source}`);
+    });
+    return {
+        body: createReadStream(source),
+        headers: {
+            'Content-Length': String(size)
+        }
+    };
+}
+/**
+ * Resolve the `new_asset_settings` for an ingest, mirroring the admin path (`upload.ts`): a
+ * `['public']` default, overlaid with the plugin's configured `newAssetSettings`, with a per-call
+ * `playbackPolicy` winning last. Keeps seeded/ingested videos in sync with admin uploads.
+ */ export function resolveNewAssetSettings(newAssetSettings, playbackPolicy) {
+    return {
+        playback_policy: [
+            'public'
+        ],
+        ...newAssetSettings,
+        ...playbackPolicy ? {
+            playback_policy: [
+                playbackPolicy
+            ]
+        } : {}
+    };
+}
+/**
+ * Ingest a video into Mux server-side: create a direct upload, PUT the source bytes (from a
+ * local path or an `http(s)` URL), and poll until the asset is `ready`. The programmatic
+ * counterpart to the admin uploader's client-side direct upload — used for seeding, imports,
+ * and migrations. Returns the ready asset.
+ *
+ * `new_asset_settings` are resolved by {@link resolveNewAssetSettings} — the plugin's configured
+ * `newAssetSettings` over a `['public']` default, with `playbackPolicy` as a per-call override —
+ * so seeded videos honor the same playback policy as admin uploads.
+ */ export async function ingestMuxAsset(mux, source, opts = {}) {
+    const upload = await mux.video.uploads.create({
+        cors_origin: opts.corsOrigin ?? '*',
+        new_asset_settings: resolveNewAssetSettings(opts.newAssetSettings, opts.playbackPolicy)
+    });
+    if (!upload.url) throw new Error(`[payload-mux] Mux did not return an upload URL for '${source}'`);
+    const { body, headers } = await buildUploadBody(source);
+    // `duplex: 'half'` is required when streaming a request body (the local-file path).
+    const res = await fetch(upload.url, {
+        method: 'PUT',
+        body,
+        headers,
+        duplex: 'half'
+    });
+    if (!res.ok) throw new Error(`[payload-mux] upload PUT failed for '${source}': ${res.status} ${res.statusText}`);
+    const ready = await pollUntil(()=>mux.video.uploads.retrieve(upload.id), (u)=>Boolean(u.asset_id), 1000);
+    if (!ready.asset_id) throw new Error(`[payload-mux] Mux upload '${upload.id}' never produced an asset`);
+    const asset = await pollUntil(()=>mux.video.assets.retrieve(ready.asset_id), (a)=>a.status !== 'preparing', 2000);
+    // Still `preparing` means the 120s pollUntil deadline passed, not a Mux verdict.
+    if (asset.status === 'preparing') throw new Error(`[payload-mux] timed out after 120s waiting for asset '${asset.id}' (status: preparing)`);
+    if (asset.status !== 'ready') {
+        const detail = asset.errors?.messages?.length ? `: ${asset.errors.messages.join('; ')}` : '';
+        throw new Error(`[payload-mux] asset '${asset.id}' did not become ready (status: ${asset.status})${detail}`);
+    }
+    return asset;
+}
+/**
+ * Create a `mux-video` doc from a local file or URL — the programmatic equivalent of uploading
+ * through the admin uploader. Hands `source` to the collection, whose `beforeValidate` hook
+ * uploads it to Mux and folds in the ready asset's metadata.
+ */ export async function ingestMuxVideo(payload, opts) {
+    const collection = opts.collection ?? 'mux-video';
+    const doc = await payload.create({
+        collection,
+        data: {
+            title: opts.title,
+            source: {
+                file: opts.source,
+                playbackPolicy: opts.playbackPolicy,
+                posterTimestamp: opts.posterTimestamp
+            }
+        },
+        overrideAccess: true
+    });
+    return doc;
+}
+
+//# sourceMappingURL=ingest.js.map

package/dist/lib/ingest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/ingest.ts"],"sourcesContent":["import { createReadStream } from 'node:fs'\nimport { stat } from 'node:fs/promises'\nimport type Mux from '@mux/mux-node'\nimport type { CollectionSlug, Payload } from 'payload'\nimport type { MuxVideoNewAssetSettings } from '../types'\nimport { delay } from './delay'\n\n/** A server-side video source: a local file path or an `http(s)` URL. */\nexport type MuxSource = string\n\n/** Poll `fetch` until `done(value)` is true or the deadline passes; returns the last value. */\nasync function pollUntil<T>(fetch: () => Promise<T>, done: (value: T) => boolean, intervalMs: number, timeoutMs = 120_000): Promise<T> {\n  const deadline = Date.now() + timeoutMs\n  let value = await fetch()\n  while (!done(value) && Date.now() < deadline) {\n    await delay(intervalMs)\n    value = await fetch()\n  }\n  return value\n}\n\n/** Build the PUT body for the Mux upload. A local path streams from disk with a Content-Length\n *  (so a large video never sits fully in memory); an `http(s)` URL is fetched and forwarded.\n *  Note: a URL source is buffered fully in memory before the PUT (Mux's upload endpoint needs a\n *  known length) — for very large remote files, download to disk and ingest the local path. */\nasync function buildUploadBody(source: MuxSource): Promise<{ body: BodyInit; headers?: Record<string, string> }> {\n  if (/^https?:\\/\\//i.test(source)) {\n    const res = await fetch(source)\n    if (!res.ok) throw new Error(`[payload-mux] failed to fetch source '${source}': ${res.status} ${res.statusText}`)\n    return { body: new Blob([await res.arrayBuffer()]) }\n  }\n  const { size } = await stat(source).catch(() => {\n    throw new Error(`[payload-mux] source file not found: ${source}`)\n  })\n  return { body: createReadStream(source) as unknown as BodyInit, headers: { 'Content-Length': String(size) } }\n}\n\nexport interface IngestMuxAssetOptions {\n  /** Base new-asset settings — normally the plugin's `uploadSettings.new_asset_settings`, so a\n   *  server-side ingest produces the same asset config as the admin direct-upload path. */\n  newAssetSettings?: MuxVideoNewAssetSettings\n  /** Playback policy override for this asset. When set, wins over `newAssetSettings`'s policy;\n   *  otherwise the configured policy applies (falling back to `'public'`). */\n  playbackPolicy?: 'public' | 'signed'\n  /** CORS origin for the direct upload. @default '*' */\n  corsOrigin?: string\n}\n\n/**\n * Resolve the `new_asset_settings` for an ingest, mirroring the admin path (`upload.ts`): a\n * `['public']` default, overlaid with the plugin's configured `newAssetSettings`, with a per-call\n * `playbackPolicy` winning last. Keeps seeded/ingested videos in sync with admin uploads.\n */\nexport function resolveNewAssetSettings(\n  newAssetSettings?: MuxVideoNewAssetSettings,\n  playbackPolicy?: 'public' | 'signed',\n): MuxVideoNewAssetSettings {\n  return {\n    playback_policy: ['public'],\n    ...newAssetSettings,\n    ...(playbackPolicy ? { playback_policy: [playbackPolicy] } : {}),\n  }\n}\n\n/**\n * Ingest a video into Mux server-side: create a direct upload, PUT the source bytes (from a\n * local path or an `http(s)` URL), and poll until the asset is `ready`. The programmatic\n * counterpart to the admin uploader's client-side direct upload — used for seeding, imports,\n * and migrations. Returns the ready asset.\n *\n * `new_asset_settings` are resolved by {@link resolveNewAssetSettings} — the plugin's configured\n * `newAssetSettings` over a `['public']` default, with `playbackPolicy` as a per-call override —\n * so seeded videos honor the same playback policy as admin uploads.\n */\nexport async function ingestMuxAsset(mux: Mux, source: MuxSource, opts: IngestMuxAssetOptions = {}): Promise<Mux.Video.Assets.Asset> {\n  const upload = await mux.video.uploads.create({\n    cors_origin: opts.corsOrigin ?? '*',\n    new_asset_settings: resolveNewAssetSettings(opts.newAssetSettings, opts.playbackPolicy),\n  })\n  if (!upload.url) throw new Error(`[payload-mux] Mux did not return an upload URL for '${source}'`)\n\n  const { body, headers } = await buildUploadBody(source)\n  // `duplex: 'half'` is required when streaming a request body (the local-file path).\n  const res = await fetch(upload.url, { method: 'PUT', body, headers, duplex: 'half' } as RequestInit & { duplex: 'half' })\n  if (!res.ok) throw new Error(`[payload-mux] upload PUT failed for '${source}': ${res.status} ${res.statusText}`)\n\n  const ready = await pollUntil(\n    () => mux.video.uploads.retrieve(upload.id),\n    (u) => Boolean(u.asset_id),\n    1000,\n  )\n  if (!ready.asset_id) throw new Error(`[payload-mux] Mux upload '${upload.id}' never produced an asset`)\n\n  const asset = await pollUntil(\n    () => mux.video.assets.retrieve(ready.asset_id as string),\n    (a) => a.status !== 'preparing',\n    2000,\n  )\n  // Still `preparing` means the 120s pollUntil deadline passed, not a Mux verdict.\n  if (asset.status === 'preparing') throw new Error(`[payload-mux] timed out after 120s waiting for asset '${asset.id}' (status: preparing)`)\n  if (asset.status !== 'ready') {\n    const detail = asset.errors?.messages?.length ? `: ${asset.errors.messages.join('; ')}` : ''\n    throw new Error(`[payload-mux] asset '${asset.id}' did not become ready (status: ${asset.status})${detail}`)\n  }\n\n  return asset\n}\n\nexport interface IngestMuxVideoOptions {\n  /** Local file path or `http(s)` URL of the video to ingest. */\n  source: MuxSource\n  /** Title for the created `mux-video` doc (must be unique within the collection). */\n  title: string\n  /** Playback policy override for the uploaded asset. @default the plugin's configured policy */\n  playbackPolicy?: 'public' | 'signed'\n  /** Optional poster timestamp (seconds). */\n  posterTimestamp?: number\n  /** The `mux-video` collection slug. @default 'mux-video' */\n  collection?: string\n}\n\n/**\n * Create a `mux-video` doc from a local file or URL — the programmatic equivalent of uploading\n * through the admin uploader. Hands `source` to the collection, whose `beforeValidate` hook\n * uploads it to Mux and folds in the ready asset's metadata.\n */\nexport async function ingestMuxVideo(payload: Payload, opts: IngestMuxVideoOptions): Promise<{ id: string | number }> {\n  const collection = (opts.collection ?? 'mux-video') as CollectionSlug\n  const doc = await payload.create({\n    collection,\n    data: {\n      title: opts.title,\n      source: { file: opts.source, playbackPolicy: opts.playbackPolicy, posterTimestamp: opts.posterTimestamp },\n    } as never,\n    overrideAccess: true,\n  })\n  return doc as { id: string | number }\n}\n"],"names":["createReadStream","stat","delay","pollUntil","fetch","done","intervalMs","timeoutMs","deadline","Date","now","value","buildUploadBody","source","test","res","ok","Error","status","statusText","body","Blob","arrayBuffer","size","catch","headers","String","resolveNewAssetSettings","newAssetSettings","playbackPolicy","playback_policy","ingestMuxAsset","mux","opts","upload","video","uploads","create","cors_origin","corsOrigin","new_asset_settings","url","method","duplex","ready","retrieve","id","u","Boolean","asset_id","asset","assets","a","detail","errors","messages","length","join","ingestMuxVideo","payload","collection","doc","data","title","file","posterTimestamp","overrideAccess"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,UAAS;AAC1C,SAASC,IAAI,QAAQ,mBAAkB;AAIvC,SAASC,KAAK,QAAQ,aAAS;AAK/B,6FAA6F,GAC7F,eAAeC,UAAaC,MAAuB,EAAEC,IAA2B,EAAEC,UAAkB,EAAEC,YAAY,OAAO;IACvH,MAAMC,WAAWC,KAAKC,GAAG,KAAKH;IAC9B,IAAII,QAAQ,MAAMP;IAClB,MAAO,CAACC,KAAKM,UAAUF,KAAKC,GAAG,KAAKF,SAAU;QAC5C,MAAMN,MAAMI;QACZK,QAAQ,MAAMP;IAChB;IACA,OAAOO;AACT;AAEA;;;6FAG6F,GAC7F,eAAeC,gBAAgBC,MAAiB;IAC9C,IAAI,gBAAgBC,IAAI,CAACD,SAAS;QAChC,MAAME,MAAM,MAAMX,MAAMS;QACxB,IAAI,CAACE,IAAIC,EAAE,EAAE,MAAM,IAAIC,MAAM,CAAC,sCAAsC,EAAEJ,OAAO,GAAG,EAAEE,IAAIG,MAAM,CAAC,CAAC,EAAEH,IAAII,UAAU,EAAE;QAChH,OAAO;YAAEC,MAAM,IAAIC,KAAK;gBAAC,MAAMN,IAAIO,WAAW;aAAG;QAAE;IACrD;IACA,MAAM,EAAEC,IAAI,EAAE,GAAG,MAAMtB,KAAKY,QAAQW,KAAK,CAAC;QACxC,MAAM,IAAIP,MAAM,CAAC,qCAAqC,EAAEJ,QAAQ;IAClE;IACA,OAAO;QAAEO,MAAMpB,iBAAiBa;QAAgCY,SAAS;YAAE,kBAAkBC,OAAOH;QAAM;IAAE;AAC9G;AAaA;;;;CAIC,GACD,OAAO,SAASI,wBACdC,gBAA2C,EAC3CC,cAAoC;IAEpC,OAAO;QACLC,iBAAiB;YAAC;SAAS;QAC3B,GAAGF,gBAAgB;QACnB,GAAIC,iBAAiB;YAAEC,iBAAiB;gBAACD;aAAe;QAAC,IAAI,CAAC,CAAC;IACjE;AACF;AAEA;;;;;;;;;CASC,GACD,OAAO,eAAeE,eAAeC,GAAQ,EAAEnB,MAAiB,EAAEoB,OAA8B,CAAC,CAAC;IAChG,MAAMC,SAAS,MAAMF,IAAIG,KAAK,CAACC,OAAO,CAACC,MAAM,CAAC;QAC5CC,aAAaL,KAAKM,UAAU,IAAI;QAChCC,oBAAoBb,wBAAwBM,KAAKL,gBAAgB,EAAEK,KAAKJ,cAAc;IACxF;IACA,IAAI,CAACK,OAAOO,GAAG,EAAE,MAAM,IAAIxB,MAAM,CAAC,oDAAoD,EAAEJ,OAAO,CAAC,CAAC;IAEjG,MAAM,EAAEO,IAAI,EAAEK,OAAO,EAAE,GAAG,MAAMb,gBAAgBC;IAChD,oFAAoF;IACpF,MAAME,MAAM,MAAMX,MAAM8B,OAAOO,GAAG,EAAE;QAAEC,QAAQ;QAAOtB;QAAMK;QAASkB,QAAQ;IAAO;IACnF,IAAI,CAAC5B,IAAIC,EAAE,EAAE,MAAM,IAAIC,MAAM,CAAC,qCAAqC,EAAEJ,OAAO,GAAG,EAAEE,IAAIG,MAAM,CAAC,CAAC,EAAEH,IAAII,UAAU,EAAE;IAE/G,MAAMyB,QAAQ,MAAMzC,UAClB,IAAM6B,IAAIG,KAAK,CAACC,OAAO,CAACS,QAAQ,CAACX,OAAOY,EAAE,GAC1C,CAACC,IAAMC,QAAQD,EAAEE,QAAQ,GACzB;IAEF,IAAI,CAACL,MAAMK,QAAQ,EAAE,MAAM,IAAIhC,MAAM,CAAC,0BAA0B,EAAEiB,OAAOY,EAAE,CAAC,yBAAyB,CAAC;IAEtG,MAAMI,QAAQ,MAAM/C,UAClB,IAAM6B,IAAIG,KAAK,CAACgB,MAAM,CAACN,QAAQ,CAACD,MAAMK,QAAQ,GAC9C,CAACG,IAAMA,EAAElC,MAAM,KAAK,aACpB;IAEF,iFAAiF;IACjF,IAAIgC,MAAMhC,MAAM,KAAK,aAAa,MAAM,IAAID,MAAM,CAAC,sDAAsD,EAAEiC,MAAMJ,EAAE,CAAC,qBAAqB,CAAC;IAC1I,IAAII,MAAMhC,MAAM,KAAK,SAAS;QAC5B,MAAMmC,SAASH,MAAMI,MAAM,EAAEC,UAAUC,SAAS,CAAC,EAAE,EAAEN,MAAMI,MAAM,CAACC,QAAQ,CAACE,IAAI,CAAC,OAAO,GAAG;QAC1F,MAAM,IAAIxC,MAAM,CAAC,qBAAqB,EAAEiC,MAAMJ,EAAE,CAAC,gCAAgC,EAAEI,MAAMhC,MAAM,CAAC,CAAC,EAAEmC,QAAQ;IAC7G;IAEA,OAAOH;AACT;AAeA;;;;CAIC,GACD,OAAO,eAAeQ,eAAeC,OAAgB,EAAE1B,IAA2B;IAChF,MAAM2B,aAAc3B,KAAK2B,UAAU,IAAI;IACvC,MAAMC,MAAM,MAAMF,QAAQtB,MAAM,CAAC;QAC/BuB;QACAE,MAAM;YACJC,OAAO9B,KAAK8B,KAAK;YACjBlD,QAAQ;gBAAEmD,MAAM/B,KAAKpB,MAAM;gBAAEgB,gBAAgBI,KAAKJ,cAAc;gBAAEoC,iBAAiBhC,KAAKgC,eAAe;YAAC;QAC1G;QACAC,gBAAgB;IAClB;IACA,OAAOL;AACT"}

package/dist/lib/isAllowed.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadRequest } from 'payload';
+import type { MuxVideoPluginOptions } from '../types';
+/** Resolve the plugin's access gate for a request: the configured `access` option if given,
+ *  else the default logged-in-admin check. Shared by the upload endpoints and the collection
+ *  `read` access so the gate stays defined in one place. */
+export declare const isAllowed: (options: MuxVideoPluginOptions, req: PayloadRequest) => Promise<boolean>;
+//# sourceMappingURL=isAllowed.d.ts.map

package/dist/lib/isAllowed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAllowed.d.ts","sourceRoot":"","sources":["../../src/lib/isAllowed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAGrD;;4DAE4D;AAC5D,eAAO,MAAM,SAAS,GAAU,SAAS,qBAAqB,EAAE,KAAK,cAAc,KAAG,OAAO,CAAC,OAAO,CAChD,CAAA"}

package/dist/lib/isAllowed.js

@@ -0,0 +1,6 @@
+import { defaultAccess } from "./defaultAccess.js";
+/** Resolve the plugin's access gate for a request: the configured `access` option if given,
+ *  else the default logged-in-admin check. Shared by the upload endpoints and the collection
+ *  `read` access so the gate stays defined in one place. */ export const isAllowed = async (options, req)=>await options.access?.(req) ?? defaultAccess(req);
+
+//# sourceMappingURL=isAllowed.js.map

package/dist/lib/isAllowed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/isAllowed.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\nimport type { MuxVideoPluginOptions } from '../types'\nimport { defaultAccess } from './defaultAccess'\n\n/** Resolve the plugin's access gate for a request: the configured `access` option if given,\n *  else the default logged-in-admin check. Shared by the upload endpoints and the collection\n *  `read` access so the gate stays defined in one place. */\nexport const isAllowed = async (options: MuxVideoPluginOptions, req: PayloadRequest): Promise<boolean> =>\n  (await options.access?.(req)) ?? defaultAccess(req)\n"],"names":["defaultAccess","isAllowed","options","req","access"],"mappings":"AAEA,SAASA,aAAa,QAAQ,qBAAiB;AAE/C;;0DAE0D,GAC1D,OAAO,MAAMC,YAAY,OAAOC,SAAgCC,MAC9D,AAAC,MAAMD,QAAQE,MAAM,GAAGD,QAASH,cAAcG,KAAI"}

package/dist/plugin.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'payload';
+import type { MuxVideoPluginOptions } from './types';
+/**
+ * Brings Mux Video to Payload. Adds a `mux-video` collection (or extends one you name),
+ * registers the upload + webhook endpoints, and wires the admin uploader. Direct uploads go
+ * straight to Mux; a webhook keeps Payload in sync and deletes cascade both ways.
+ *
+ * Credentials default to the standard `MUX_*` env vars, so `muxVideoPlugin()` is enough — pass
+ * options only to override (custom env var name, playback policy, etc).
+ */
+export declare const muxVideoPlugin: (pluginOptions?: MuxVideoPluginOptions) => Plugin;
+export default muxVideoPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,SAAS,CAAA;AAK7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GACxB,gBAAe,qBAA0B,KAAG,MAqD5C,CAAA;AAEH,eAAe,cAAc,CAAA"}

package/dist/plugin.js

@@ -0,0 +1,80 @@
+import Mux from "@mux/mux-node";
+import { deepMerge } from "payload";
+import { MuxVideo } from "./collections/MuxVideo.js";
+import { createMuxUploadHandler, getMuxUploadHandler } from "./endpoints/upload.js";
+import { muxWebhookHandler } from "./endpoints/webhook.js";
+/**
+ * Brings Mux Video to Payload. Adds a `mux-video` collection (or extends one you name),
+ * registers the upload + webhook endpoints, and wires the admin uploader. Direct uploads go
+ * straight to Mux; a webhook keeps Payload in sync and deletes cascade both ways.
+ *
+ * Credentials default to the standard `MUX_*` env vars, so `muxVideoPlugin()` is enough — pass
+ * options only to override (custom env var name, playback policy, etc).
+ */ export const muxVideoPlugin = (pluginOptions = {})=>(incomingConfig)=>{
+        if (pluginOptions.enabled === false) return incomingConfig;
+        const mux = new Mux(pluginOptions.initSettings);
+        // Expose the options on config.custom so external tooling (e.g. a seeder) can build a Mux
+        // client from the already-configured credentials, given just `payload` — read by string
+        // key, no import, so other packages stay decoupled from this one.
+        const config = {
+            ...incomingConfig,
+            custom: {
+                ...incomingConfig.custom,
+                payloadMux: {
+                    options: pluginOptions
+                }
+            }
+        };
+        // Without credentials the collection still registers (so generated types stay stable), but
+        // ingest can't reach Mux — mark it seed-disabled so a seeder skips its definition with this
+        // reason instead of failing mid-run. Set the env vars and the next seed picks it up.
+        const hasCreds = Boolean((pluginOptions.initSettings?.tokenId ?? process.env.MUX_TOKEN_ID) && (pluginOptions.initSettings?.tokenSecret ?? process.env.MUX_TOKEN_SECRET));
+        const collection = MuxVideo(mux, pluginOptions);
+        if (!hasCreds) {
+            collection.custom = {
+                ...collection.custom,
+                seedDisabled: 'Mux credentials not set (MUX_TOKEN_ID / MUX_TOKEN_SECRET)'
+            };
+            console.warn('[payload-mux] MUX_TOKEN_ID / MUX_TOKEN_SECRET not set — uploads, server-side ingest, and webhook handling will fail');
+        }
+        // Signed playback needs the JWT key pair — without it every read of a signed video throws
+        // in the virtual URL fields, so warn at boot instead of failing per-request.
+        const signed = pluginOptions.playbackPolicy === 'signed' || pluginOptions.uploadSettings?.new_asset_settings?.playback_policy?.includes('signed');
+        const hasSigningKeys = Boolean((pluginOptions.initSettings?.jwtSigningKey ?? process.env.MUX_SIGNING_KEY) && (pluginOptions.initSettings?.jwtPrivateKey ?? process.env.MUX_PRIVATE_KEY));
+        if (signed && !hasSigningKeys) console.warn('[payload-mux] signed playback is configured but MUX_SIGNING_KEY / MUX_PRIVATE_KEY not set — signed video reads will fail');
+        if (pluginOptions.extendCollection) {
+            const target = config.collections?.find((c)=>c.slug === pluginOptions.extendCollection);
+            if (!target) throw new Error(`[payload-mux] extendCollection: collection '${pluginOptions.extendCollection}' not found`);
+            config.collections = [
+                ...(config.collections ?? []).filter((c)=>c.slug !== pluginOptions.extendCollection),
+                deepMerge(collection, target)
+            ];
+        } else {
+            config.collections = [
+                ...config.collections ?? [],
+                collection
+            ];
+        }
+        config.endpoints = [
+            ...config.endpoints ?? [],
+            {
+                method: 'post',
+                path: '/mux/upload',
+                handler: createMuxUploadHandler(mux, pluginOptions)
+            },
+            {
+                method: 'get',
+                path: '/mux/upload',
+                handler: getMuxUploadHandler(mux, pluginOptions)
+            },
+            {
+                method: 'post',
+                path: '/mux/webhook',
+                handler: muxWebhookHandler(mux, pluginOptions)
+            }
+        ];
+        return config;
+    };
+export default muxVideoPlugin;
+
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugin.ts"],"sourcesContent":["import Mux from '@mux/mux-node'\nimport type { Config, Plugin } from 'payload'\nimport { deepMerge } from 'payload'\nimport { MuxVideo } from './collections/MuxVideo'\nimport { createMuxUploadHandler, getMuxUploadHandler } from './endpoints/upload'\nimport { muxWebhookHandler } from './endpoints/webhook'\nimport type { MuxVideoPluginOptions } from './types'\n\n/**\n * Brings Mux Video to Payload. Adds a `mux-video` collection (or extends one you name),\n * registers the upload + webhook endpoints, and wires the admin uploader. Direct uploads go\n * straight to Mux; a webhook keeps Payload in sync and deletes cascade both ways.\n *\n * Credentials default to the standard `MUX_*` env vars, so `muxVideoPlugin()` is enough — pass\n * options only to override (custom env var name, playback policy, etc).\n */\nexport const muxVideoPlugin =\n  (pluginOptions: MuxVideoPluginOptions = {}): Plugin =>\n  (incomingConfig: Config): Config => {\n    if (pluginOptions.enabled === false) return incomingConfig\n\n    const mux = new Mux(pluginOptions.initSettings)\n    // Expose the options on config.custom so external tooling (e.g. a seeder) can build a Mux\n    // client from the already-configured credentials, given just `payload` — read by string\n    // key, no import, so other packages stay decoupled from this one.\n    const config: Config = { ...incomingConfig, custom: { ...incomingConfig.custom, payloadMux: { options: pluginOptions } } }\n\n    // Without credentials the collection still registers (so generated types stay stable), but\n    // ingest can't reach Mux — mark it seed-disabled so a seeder skips its definition with this\n    // reason instead of failing mid-run. Set the env vars and the next seed picks it up.\n    const hasCreds = Boolean(\n      (pluginOptions.initSettings?.tokenId ?? process.env.MUX_TOKEN_ID) &&\n        (pluginOptions.initSettings?.tokenSecret ?? process.env.MUX_TOKEN_SECRET),\n    )\n    const collection = MuxVideo(mux, pluginOptions)\n    if (!hasCreds) {\n      collection.custom = { ...collection.custom, seedDisabled: 'Mux credentials not set (MUX_TOKEN_ID / MUX_TOKEN_SECRET)' }\n      console.warn('[payload-mux] MUX_TOKEN_ID / MUX_TOKEN_SECRET not set — uploads, server-side ingest, and webhook handling will fail')\n    }\n\n    // Signed playback needs the JWT key pair — without it every read of a signed video throws\n    // in the virtual URL fields, so warn at boot instead of failing per-request.\n    const signed =\n      pluginOptions.playbackPolicy === 'signed' || pluginOptions.uploadSettings?.new_asset_settings?.playback_policy?.includes('signed')\n    const hasSigningKeys = Boolean(\n      (pluginOptions.initSettings?.jwtSigningKey ?? process.env.MUX_SIGNING_KEY) &&\n        (pluginOptions.initSettings?.jwtPrivateKey ?? process.env.MUX_PRIVATE_KEY),\n    )\n    if (signed && !hasSigningKeys)\n      console.warn('[payload-mux] signed playback is configured but MUX_SIGNING_KEY / MUX_PRIVATE_KEY not set — signed video reads will fail')\n\n    if (pluginOptions.extendCollection) {\n      const target = config.collections?.find((c) => c.slug === pluginOptions.extendCollection)\n      if (!target) throw new Error(`[payload-mux] extendCollection: collection '${pluginOptions.extendCollection}' not found`)\n      config.collections = [\n        ...(config.collections ?? []).filter((c) => c.slug !== pluginOptions.extendCollection),\n        deepMerge(collection, target),\n      ]\n    } else {\n      config.collections = [...(config.collections ?? []), collection]\n    }\n\n    config.endpoints = [\n      ...(config.endpoints ?? []),\n      { method: 'post', path: '/mux/upload', handler: createMuxUploadHandler(mux, pluginOptions) },\n      { method: 'get', path: '/mux/upload', handler: getMuxUploadHandler(mux, pluginOptions) },\n      { method: 'post', path: '/mux/webhook', handler: muxWebhookHandler(mux, pluginOptions) },\n    ]\n\n    return config\n  }\n\nexport default muxVideoPlugin\n"],"names":["Mux","deepMerge","MuxVideo","createMuxUploadHandler","getMuxUploadHandler","muxWebhookHandler","muxVideoPlugin","pluginOptions","incomingConfig","enabled","mux","initSettings","config","custom","payloadMux","options","hasCreds","Boolean","tokenId","process","env","MUX_TOKEN_ID","tokenSecret","MUX_TOKEN_SECRET","collection","seedDisabled","console","warn","signed","playbackPolicy","uploadSettings","new_asset_settings","playback_policy","includes","hasSigningKeys","jwtSigningKey","MUX_SIGNING_KEY","jwtPrivateKey","MUX_PRIVATE_KEY","extendCollection","target","collections","find","c","slug","Error","filter","endpoints","method","path","handler"],"mappings":"AAAA,OAAOA,SAAS,gBAAe;AAE/B,SAASC,SAAS,QAAQ,UAAS;AACnC,SAASC,QAAQ,QAAQ,4BAAwB;AACjD,SAASC,sBAAsB,EAAEC,mBAAmB,QAAQ,wBAAoB;AAChF,SAASC,iBAAiB,QAAQ,yBAAqB;AAGvD;;;;;;;CAOC,GACD,OAAO,MAAMC,iBACX,CAACC,gBAAuC,CAAC,CAAC,GAC1C,CAACC;QACC,IAAID,cAAcE,OAAO,KAAK,OAAO,OAAOD;QAE5C,MAAME,MAAM,IAAIV,IAAIO,cAAcI,YAAY;QAC9C,0FAA0F;QAC1F,wFAAwF;QACxF,kEAAkE;QAClE,MAAMC,SAAiB;YAAE,GAAGJ,cAAc;YAAEK,QAAQ;gBAAE,GAAGL,eAAeK,MAAM;gBAAEC,YAAY;oBAAEC,SAASR;gBAAc;YAAE;QAAE;QAEzH,2FAA2F;QAC3F,4FAA4F;QAC5F,qFAAqF;QACrF,MAAMS,WAAWC,QACf,AAACV,CAAAA,cAAcI,YAAY,EAAEO,WAAWC,QAAQC,GAAG,CAACC,YAAY,AAAD,KAC5Dd,CAAAA,cAAcI,YAAY,EAAEW,eAAeH,QAAQC,GAAG,CAACG,gBAAgB,AAAD;QAE3E,MAAMC,aAAatB,SAASQ,KAAKH;QACjC,IAAI,CAACS,UAAU;YACbQ,WAAWX,MAAM,GAAG;gBAAE,GAAGW,WAAWX,MAAM;gBAAEY,cAAc;YAA4D;YACtHC,QAAQC,IAAI,CAAC;QACf;QAEA,0FAA0F;QAC1F,6EAA6E;QAC7E,MAAMC,SACJrB,cAAcsB,cAAc,KAAK,YAAYtB,cAAcuB,cAAc,EAAEC,oBAAoBC,iBAAiBC,SAAS;QAC3H,MAAMC,iBAAiBjB,QACrB,AAACV,CAAAA,cAAcI,YAAY,EAAEwB,iBAAiBhB,QAAQC,GAAG,CAACgB,eAAe,AAAD,KACrE7B,CAAAA,cAAcI,YAAY,EAAE0B,iBAAiBlB,QAAQC,GAAG,CAACkB,eAAe,AAAD;QAE5E,IAAIV,UAAU,CAACM,gBACbR,QAAQC,IAAI,CAAC;QAEf,IAAIpB,cAAcgC,gBAAgB,EAAE;YAClC,MAAMC,SAAS5B,OAAO6B,WAAW,EAAEC,KAAK,CAACC,IAAMA,EAAEC,IAAI,KAAKrC,cAAcgC,gBAAgB;YACxF,IAAI,CAACC,QAAQ,MAAM,IAAIK,MAAM,CAAC,4CAA4C,EAAEtC,cAAcgC,gBAAgB,CAAC,WAAW,CAAC;YACvH3B,OAAO6B,WAAW,GAAG;mBAChB,AAAC7B,CAAAA,OAAO6B,WAAW,IAAI,EAAE,AAAD,EAAGK,MAAM,CAAC,CAACH,IAAMA,EAAEC,IAAI,KAAKrC,cAAcgC,gBAAgB;gBACrFtC,UAAUuB,YAAYgB;aACvB;QACH,OAAO;YACL5B,OAAO6B,WAAW,GAAG;mBAAK7B,OAAO6B,WAAW,IAAI,EAAE;gBAAGjB;aAAW;QAClE;QAEAZ,OAAOmC,SAAS,GAAG;eACbnC,OAAOmC,SAAS,IAAI,EAAE;YAC1B;gBAAEC,QAAQ;gBAAQC,MAAM;gBAAeC,SAAS/C,uBAAuBO,KAAKH;YAAe;YAC3F;gBAAEyC,QAAQ;gBAAOC,MAAM;gBAAeC,SAAS9C,oBAAoBM,KAAKH;YAAe;YACvF;gBAAEyC,QAAQ;gBAAQC,MAAM;gBAAgBC,SAAS7C,kBAAkBK,KAAKH;YAAe;SACxF;QAED,OAAOK;IACT,EAAC;AAEH,eAAeN,eAAc"}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+import type Mux from '@mux/mux-node';
+import type { PayloadRequest, TypedCollection } from 'payload';
+/** Mux's asset-creation params, via the SDK namespace (avoids a deep subpath import). */
+type AssetOptions = Mux.Video.Assets.AssetOptions;
+/**
+ * Mux API credentials + webhook/signing secrets. Every field is optional: anything you don't
+ * pass is read from the standard Mux environment variables by the SDK —
+ * `MUX_TOKEN_ID`, `MUX_TOKEN_SECRET`, `MUX_WEBHOOK_SECRET`, `MUX_SIGNING_KEY`,
+ * `MUX_PRIVATE_KEY`. Only pass a field to override it (e.g. a non-standard env var name).
+ */
+export interface MuxVideoInitSettings {
+    /** The Mux token ID. @default process.env.MUX_TOKEN_ID */
+    tokenId?: string;
+    /** The Mux token secret. @default process.env.MUX_TOKEN_SECRET */
+    tokenSecret?: string;
+    /** The secret used to verify incoming Mux webhooks. @default process.env.MUX_WEBHOOK_SECRET */
+    webhookSecret?: string;
+    /** JWT signing key ID (signed playback). @default process.env.MUX_SIGNING_KEY */
+    jwtSigningKey?: string;
+    /** JWT private key (signed playback). @default process.env.MUX_PRIVATE_KEY */
+    jwtPrivateKey?: string;
+}
+/** `new_asset_settings` passed to Mux when creating an asset, plus the playback policy. */
+export type MuxVideoNewAssetSettings = AssetOptions & {
+    /** Playback policy for uploaded videos. `['public']` by default; use `['signed']` for
+     *  the signed-URL setup. */
+    playback_policy?: Array<'public' | 'signed'>;
+};
+/** Settings applied to every upload. */
+export interface MuxVideoUploadSettings {
+    /** CORS origin for the direct-upload URL (usually your site URL).
+     *  @default process.env.NEXT_PUBLIC_SERVER_URL, falling back to '*' */
+    cors_origin?: string;
+    /** Extra settings forwarded to Mux when the asset is created. */
+    new_asset_settings?: MuxVideoNewAssetSettings;
+}
+/** Signed-URL generation options. */
+export interface MuxVideoSignedUrlOptions {
+    /** Expiration window for signed playback/poster/gif URLs. @default "1d" */
+    expiration?: string;
+}
+/** Configuration for the Mux Video plugin. */
+export interface MuxVideoPluginOptions {
+    /** Set to `false` to disable the plugin (collection, endpoints, and hooks are skipped).
+     *  @default true */
+    enabled?: boolean;
+    /** Mux credentials + webhook secret. Optional — fields default to the standard `MUX_*`
+     *  environment variables, so you only pass this to override an env var. */
+    initSettings?: MuxVideoInitSettings;
+    /** Upload settings (CORS origin + new-asset settings). Optional — `cors_origin` defaults
+     *  to `NEXT_PUBLIC_SERVER_URL`. */
+    uploadSettings?: MuxVideoUploadSettings;
+    /** Playback policy for newly uploaded videos: `'public'` URLs, or `'signed'` JWT-signed
+     *  URLs (also set `MUX_SIGNING_KEY` + `MUX_PRIVATE_KEY`). Shorthand for
+     *  `uploadSettings.new_asset_settings.playback_policy`; an explicit value there wins.
+     *  @default 'public' */
+    playbackPolicy?: 'public' | 'signed';
+    /** Slug of an existing collection to extend with Mux fields instead of creating the
+     *  default `mux-video` collection. */
+    extendCollection?: keyof TypedCollection;
+    /** Gate who may request an upload / read videos. Defaults to logged-in admins. */
+    access?: (request: PayloadRequest) => Promise<boolean> | boolean;
+    /** Signed-URL generation options. */
+    signedUrlOptions?: MuxVideoSignedUrlOptions;
+    /** Image format for video posters. @default "png" */
+    posterExtension?: 'webp' | 'jpg' | 'png';
+    /** Image format for animated preview thumbnails. @default "gif" */
+    animatedGifExtension?: 'gif' | 'webp';
+    /** Thumbnail shown in the collection list view: animated `gif`, static `image`, or
+     *  `none`. @default "gif" */
+    adminThumbnail?: 'gif' | 'image' | 'none';
+    /** When set, the webhook creates a Payload doc for a Mux asset that doesn't exist yet
+     *  (on `video.asset.created` / `ready` / `updated`) — backfills videos uploaded directly
+     *  in Mux. @default false */
+    autoCreateOnWebhook?: boolean;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9D,yFAAyF;AACzF,KAAK,YAAY,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAA;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+FAA+F;IAC/F,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,2FAA2F;AAC3F,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG;IACpD;gCAC4B;IAC5B,eAAe,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAA;CAC7C,CAAA;AAED,wCAAwC;AACxC,MAAM,WAAW,sBAAsB;IACrC;2EACuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iEAAiE;IACjE,kBAAkB,CAAC,EAAE,wBAAwB,CAAA;CAC9C;AAED,qCAAqC;AACrC,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;wBACoB;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;+EAC2E;IAC3E,YAAY,CAAC,EAAE,oBAAoB,CAAA;IACnC;uCACmC;IACnC,cAAc,CAAC,EAAE,sBAAsB,CAAA;IACvC;;;4BAGwB;IACxB,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACpC;0CACsC;IACtC,gBAAgB,CAAC,EAAE,MAAM,eAAe,CAAA;IACxC,kFAAkF;IAClF,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;IAChE,qCAAqC;IACrC,gBAAgB,CAAC,EAAE,wBAAwB,CAAA;IAC3C,qDAAqD;IACrD,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,CAAA;IACxC,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACrC;iCAC6B;IAC7B,cAAc,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAAA;IACzC;;iCAE6B;IAC7B,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B"}

package/dist/types.js

@@ -0,0 +1,3 @@
+/** Configuration for the Mux Video plugin. */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { PayloadRequest, TypedCollection } from 'payload'\n\n/** Mux's asset-creation params, via the SDK namespace (avoids a deep subpath import). */\ntype AssetOptions = Mux.Video.Assets.AssetOptions\n\n/**\n * Mux API credentials + webhook/signing secrets. Every field is optional: anything you don't\n * pass is read from the standard Mux environment variables by the SDK —\n * `MUX_TOKEN_ID`, `MUX_TOKEN_SECRET`, `MUX_WEBHOOK_SECRET`, `MUX_SIGNING_KEY`,\n * `MUX_PRIVATE_KEY`. Only pass a field to override it (e.g. a non-standard env var name).\n */\nexport interface MuxVideoInitSettings {\n  /** The Mux token ID. @default process.env.MUX_TOKEN_ID */\n  tokenId?: string\n  /** The Mux token secret. @default process.env.MUX_TOKEN_SECRET */\n  tokenSecret?: string\n  /** The secret used to verify incoming Mux webhooks. @default process.env.MUX_WEBHOOK_SECRET */\n  webhookSecret?: string\n  /** JWT signing key ID (signed playback). @default process.env.MUX_SIGNING_KEY */\n  jwtSigningKey?: string\n  /** JWT private key (signed playback). @default process.env.MUX_PRIVATE_KEY */\n  jwtPrivateKey?: string\n}\n\n/** `new_asset_settings` passed to Mux when creating an asset, plus the playback policy. */\nexport type MuxVideoNewAssetSettings = AssetOptions & {\n  /** Playback policy for uploaded videos. `['public']` by default; use `['signed']` for\n   *  the signed-URL setup. */\n  playback_policy?: Array<'public' | 'signed'>\n}\n\n/** Settings applied to every upload. */\nexport interface MuxVideoUploadSettings {\n  /** CORS origin for the direct-upload URL (usually your site URL).\n   *  @default process.env.NEXT_PUBLIC_SERVER_URL, falling back to '*' */\n  cors_origin?: string\n  /** Extra settings forwarded to Mux when the asset is created. */\n  new_asset_settings?: MuxVideoNewAssetSettings\n}\n\n/** Signed-URL generation options. */\nexport interface MuxVideoSignedUrlOptions {\n  /** Expiration window for signed playback/poster/gif URLs. @default \"1d\" */\n  expiration?: string\n}\n\n/** Configuration for the Mux Video plugin. */\nexport interface MuxVideoPluginOptions {\n  /** Set to `false` to disable the plugin (collection, endpoints, and hooks are skipped).\n   *  @default true */\n  enabled?: boolean\n  /** Mux credentials + webhook secret. Optional — fields default to the standard `MUX_*`\n   *  environment variables, so you only pass this to override an env var. */\n  initSettings?: MuxVideoInitSettings\n  /** Upload settings (CORS origin + new-asset settings). Optional — `cors_origin` defaults\n   *  to `NEXT_PUBLIC_SERVER_URL`. */\n  uploadSettings?: MuxVideoUploadSettings\n  /** Playback policy for newly uploaded videos: `'public'` URLs, or `'signed'` JWT-signed\n   *  URLs (also set `MUX_SIGNING_KEY` + `MUX_PRIVATE_KEY`). Shorthand for\n   *  `uploadSettings.new_asset_settings.playback_policy`; an explicit value there wins.\n   *  @default 'public' */\n  playbackPolicy?: 'public' | 'signed'\n  /** Slug of an existing collection to extend with Mux fields instead of creating the\n   *  default `mux-video` collection. */\n  extendCollection?: keyof TypedCollection\n  /** Gate who may request an upload / read videos. Defaults to logged-in admins. */\n  access?: (request: PayloadRequest) => Promise<boolean> | boolean\n  /** Signed-URL generation options. */\n  signedUrlOptions?: MuxVideoSignedUrlOptions\n  /** Image format for video posters. @default \"png\" */\n  posterExtension?: 'webp' | 'jpg' | 'png'\n  /** Image format for animated preview thumbnails. @default \"gif\" */\n  animatedGifExtension?: 'gif' | 'webp'\n  /** Thumbnail shown in the collection list view: animated `gif`, static `image`, or\n   *  `none`. @default \"gif\" */\n  adminThumbnail?: 'gif' | 'image' | 'none'\n  /** When set, the webhook creates a Payload doc for a Mux asset that doesn't exist yet\n   *  (on `video.asset.created` / `ready` / `updated`) — backfills videos uploaded directly\n   *  in Mux. @default false */\n  autoCreateOnWebhook?: boolean\n}\n"],"names":[],"mappings":"AA+CA,4CAA4C,GAC5C,WAiCC"}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@pro-laico/payload-mux",
+  "version": "0.0.0",
+  "description": "Mux Video for Payload CMS: a Videos collection that uploads straight to Mux, signed or public playback, virtual playback/poster/gif URLs, two-way delete, and an admin uploader + list-view previews.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pro-laico/payload-plugins.git",
+    "directory": "packages/payload-mux"
+  },
+  "keywords": [
+    "payload",
+    "payloadcms",
+    "plugin",
+    "mux",
+    "video",
+    "upload"
+  ],
+  "sideEffects": [
+    "*.scss",
+    "*.css"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./components/MuxUploaderField": {
+      "types": "./dist/components/MuxUploaderField.d.ts",
+      "import": "./dist/components/MuxUploaderField.js",
+      "default": "./dist/components/MuxUploaderField.js"
+    },
+    "./components/MuxVideoGifCell": {
+      "types": "./dist/components/MuxVideoGifCell.d.ts",
+      "import": "./dist/components/MuxVideoGifCell.js",
+      "default": "./dist/components/MuxVideoGifCell.js"
+    },
+    "./components/MuxVideoImageCell": {
+      "types": "./dist/components/MuxVideoImageCell.d.ts",
+      "import": "./dist/components/MuxVideoImageCell.js",
+      "default": "./dist/components/MuxVideoImageCell.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mux/mux-node": "^14.1.1",
+    "@mux/mux-player-react": "^3.13.0",
+    "@mux/mux-uploader-react": "^1.5.0"
+  },
+  "peerDependencies": {
+    "@payloadcms/ui": "^3.0.0",
+    "payload": "^3.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@payloadcms/ui": "^3.85.1",
+    "@types/node": "^26.0.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "payload": "^3.85.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "pnpm clean && pnpm build:types && pnpm build:swc && pnpm build:assets",
+    "clean": "rimraf dist tsconfig.tsbuildinfo",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build:swc": "swc ./src -d ./dist --config-file ../../.swcrc --strip-leading-paths",
+    "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck",
+    "build:assets": "copyfiles -u 1 \"src/**/*.css\" dist"
+  }
+}