@pro-laico/payload-mux 0.0.0

package/dist/components/mux-uploader.css

@@ -0,0 +1,23 @@
+.mux-uploader {
+  margin-bottom: var(--base);
+}
+
+.mux-uploader__error {
+  color: var(--theme-error-500);
+}
+
+.mux-uploader__processing::after {
+  display: inline-block;
+  overflow: hidden;
+  width: 0;
+  vertical-align: bottom;
+  /* ascii code for the ellipsis character */
+  content: "\2026";
+  animation: mux-ellipsis steps(5, end) 1.5s infinite;
+}
+
+@keyframes mux-ellipsis {
+  to {
+    width: 2ch;
+  }
+}

package/dist/endpoints/upload.d.ts

@@ -0,0 +1,10 @@
+import type Mux from '@mux/mux-node';
+import type { PayloadHandler } from 'payload';
+import type { MuxVideoPluginOptions } from '../types';
+/** `POST /api/mux/upload` — create a Mux direct-upload and return it (the admin uploader
+ *  POSTs files straight to the returned URL). Gated by the plugin's `access` option. */
+export declare const createMuxUploadHandler: (mux: Mux, pluginOptions: MuxVideoPluginOptions) => PayloadHandler;
+/** `GET /api/mux/upload?id=…` — retrieve a direct-upload by id so the client can read the
+ *  `asset_id` once Mux assigns it. Gated by the plugin's `access` option. */
+export declare const getMuxUploadHandler: (mux: Mux, pluginOptions: MuxVideoPluginOptions) => PayloadHandler;
+//# sourceMappingURL=upload.d.ts.map

package/dist/endpoints/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/endpoints/upload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAErD;wFACwF;AACxF,eAAO,MAAM,sBAAsB,GAChC,KAAK,GAAG,EAAE,eAAe,qBAAqB,KAAG,cAUjD,CAAA;AAEH;6EAC6E;AAC7E,eAAO,MAAM,mBAAmB,GAC7B,KAAK,GAAG,EAAE,eAAe,qBAAqB,KAAG,cAcjD,CAAA"}

package/dist/endpoints/upload.js

@@ -0,0 +1,49 @@
+import { isAllowed } from "../lib/isAllowed.js";
+/** `POST /api/mux/upload` — create a Mux direct-upload and return it (the admin uploader
+ *  POSTs files straight to the returned URL). Gated by the plugin's `access` option. */ export const createMuxUploadHandler = (mux, pluginOptions)=>async (req)=>{
+        if (!await isAllowed(pluginOptions, req)) return Response.json({
+            error: 'Forbidden.'
+        }, {
+            status: 403
+        });
+        const upload = await mux.video.uploads.create({
+            cors_origin: pluginOptions.uploadSettings?.cors_origin ?? process.env.NEXT_PUBLIC_SERVER_URL ?? '*',
+            new_asset_settings: {
+                playback_policy: [
+                    pluginOptions.playbackPolicy ?? 'public'
+                ],
+                ...pluginOptions.uploadSettings?.new_asset_settings
+            }
+        });
+        return Response.json(upload);
+    };
+/** `GET /api/mux/upload?id=…` — retrieve a direct-upload by id so the client can read the
+ *  `asset_id` once Mux assigns it. Gated by the plugin's `access` option. */ export const getMuxUploadHandler = (mux, pluginOptions)=>async (req)=>{
+        if (!await isAllowed(pluginOptions, req)) return Response.json({
+            error: 'Forbidden.'
+        }, {
+            status: 403
+        });
+        const id = req.query?.id;
+        if (!id) return Response.json({
+            error: 'Missing upload id.'
+        }, {
+            status: 400
+        });
+        try {
+            const upload = await mux.video.uploads.retrieve(id);
+            return Response.json(upload);
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: `[payload-mux] Failed to retrieve upload '${id}'`
+            });
+            return Response.json({
+                error: 'Failed to retrieve upload.'
+            }, {
+                status: 500
+            });
+        }
+    };
+
+//# sourceMappingURL=upload.js.map

package/dist/endpoints/upload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/upload.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { PayloadHandler } from 'payload'\nimport { isAllowed } from '../lib/isAllowed'\nimport type { MuxVideoPluginOptions } from '../types'\n\n/** `POST /api/mux/upload` — create a Mux direct-upload and return it (the admin uploader\n *  POSTs files straight to the returned URL). Gated by the plugin's `access` option. */\nexport const createMuxUploadHandler =\n  (mux: Mux, pluginOptions: MuxVideoPluginOptions): PayloadHandler =>\n  async (req) => {\n    if (!(await isAllowed(pluginOptions, req))) return Response.json({ error: 'Forbidden.' }, { status: 403 })\n\n    const upload = await mux.video.uploads.create({\n      cors_origin: pluginOptions.uploadSettings?.cors_origin ?? process.env.NEXT_PUBLIC_SERVER_URL ?? '*',\n      new_asset_settings: { playback_policy: [pluginOptions.playbackPolicy ?? 'public'], ...pluginOptions.uploadSettings?.new_asset_settings },\n    })\n\n    return Response.json(upload)\n  }\n\n/** `GET /api/mux/upload?id=…` — retrieve a direct-upload by id so the client can read the\n *  `asset_id` once Mux assigns it. Gated by the plugin's `access` option. */\nexport const getMuxUploadHandler =\n  (mux: Mux, pluginOptions: MuxVideoPluginOptions): PayloadHandler =>\n  async (req) => {\n    if (!(await isAllowed(pluginOptions, req))) return Response.json({ error: 'Forbidden.' }, { status: 403 })\n\n    const id = req.query?.id as string | undefined\n    if (!id) return Response.json({ error: 'Missing upload id.' }, { status: 400 })\n\n    try {\n      const upload = await mux.video.uploads.retrieve(id)\n      return Response.json(upload)\n    } catch (err) {\n      req.payload.logger.error({ err, msg: `[payload-mux] Failed to retrieve upload '${id}'` })\n      return Response.json({ error: 'Failed to retrieve upload.' }, { status: 500 })\n    }\n  }\n"],"names":["isAllowed","createMuxUploadHandler","mux","pluginOptions","req","Response","json","error","status","upload","video","uploads","create","cors_origin","uploadSettings","process","env","NEXT_PUBLIC_SERVER_URL","new_asset_settings","playback_policy","playbackPolicy","getMuxUploadHandler","id","query","retrieve","err","payload","logger","msg"],"mappings":"AAEA,SAASA,SAAS,QAAQ,sBAAkB;AAG5C;sFACsF,GACtF,OAAO,MAAMC,yBACX,CAACC,KAAUC,gBACX,OAAOC;QACL,IAAI,CAAE,MAAMJ,UAAUG,eAAeC,MAAO,OAAOC,SAASC,IAAI,CAAC;YAAEC,OAAO;QAAa,GAAG;YAAEC,QAAQ;QAAI;QAExG,MAAMC,SAAS,MAAMP,IAAIQ,KAAK,CAACC,OAAO,CAACC,MAAM,CAAC;YAC5CC,aAAaV,cAAcW,cAAc,EAAED,eAAeE,QAAQC,GAAG,CAACC,sBAAsB,IAAI;YAChGC,oBAAoB;gBAAEC,iBAAiB;oBAAChB,cAAciB,cAAc,IAAI;iBAAS;gBAAE,GAAGjB,cAAcW,cAAc,EAAEI,kBAAkB;YAAC;QACzI;QAEA,OAAOb,SAASC,IAAI,CAACG;IACvB,EAAC;AAEH;2EAC2E,GAC3E,OAAO,MAAMY,sBACX,CAACnB,KAAUC,gBACX,OAAOC;QACL,IAAI,CAAE,MAAMJ,UAAUG,eAAeC,MAAO,OAAOC,SAASC,IAAI,CAAC;YAAEC,OAAO;QAAa,GAAG;YAAEC,QAAQ;QAAI;QAExG,MAAMc,KAAKlB,IAAImB,KAAK,EAAED;QACtB,IAAI,CAACA,IAAI,OAAOjB,SAASC,IAAI,CAAC;YAAEC,OAAO;QAAqB,GAAG;YAAEC,QAAQ;QAAI;QAE7E,IAAI;YACF,MAAMC,SAAS,MAAMP,IAAIQ,KAAK,CAACC,OAAO,CAACa,QAAQ,CAACF;YAChD,OAAOjB,SAASC,IAAI,CAACG;QACvB,EAAE,OAAOgB,KAAK;YACZrB,IAAIsB,OAAO,CAACC,MAAM,CAACpB,KAAK,CAAC;gBAAEkB;gBAAKG,KAAK,CAAC,yCAAyC,EAAEN,GAAG,CAAC,CAAC;YAAC;YACvF,OAAOjB,SAASC,IAAI,CAAC;gBAAEC,OAAO;YAA6B,GAAG;gBAAEC,QAAQ;YAAI;QAC9E;IACF,EAAC"}

package/dist/endpoints/webhook.d.ts

@@ -0,0 +1,16 @@
+import type Mux from '@mux/mux-node';
+import type { PayloadHandler } from 'payload';
+import type { MuxVideoPluginOptions } from '../types';
+/**
+ * `POST /api/mux/webhook` — keep Payload in sync with Mux. `unwrap()` verifies the Mux
+ * signature and returns a typed event; we then set metadata + status on `video.asset.ready` /
+ * `updated`, delete the doc on `video.asset.deleted`, mark the doc errored on
+ * `video.asset.errored`, and (when `autoCreateOnWebhook`) backfill a doc for an asset Payload
+ * doesn't have yet. 200s after a handled event so Mux stops retrying; 500s on a failed
+ * handler so Mux retries it.
+ *
+ * Note: Payload pre-parses the request body, so the signature is verified against a
+ * re-serialized payload rather than the original bytes — unavoidable at the endpoint layer.
+ */
+export declare const muxWebhookHandler: (mux: Mux, pluginOptions: MuxVideoPluginOptions) => PayloadHandler;
+//# sourceMappingURL=webhook.d.ts.map

package/dist/endpoints/webhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.d.ts","sourceRoot":"","sources":["../../src/endpoints/webhook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAQrD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC3B,KAAK,GAAG,EAAE,eAAe,qBAAqB,KAAG,cAuEjD,CAAA"}

package/dist/endpoints/webhook.js

@@ -0,0 +1,148 @@
+import { getAssetMetadata } from "../lib/getAssetMetadata.js";
+const ok = ()=>new Response('Success!', {
+        status: 200
+    });
+const fail = ()=>new Response('Error', {
+        status: 500
+    });
+// One info line per process so users can confirm the webhook wiring end to end.
+let verifiedLogged = false;
+/**
+ * `POST /api/mux/webhook` — keep Payload in sync with Mux. `unwrap()` verifies the Mux
+ * signature and returns a typed event; we then set metadata + status on `video.asset.ready` /
+ * `updated`, delete the doc on `video.asset.deleted`, mark the doc errored on
+ * `video.asset.errored`, and (when `autoCreateOnWebhook`) backfill a doc for an asset Payload
+ * doesn't have yet. 200s after a handled event so Mux stops retrying; 500s on a failed
+ * handler so Mux retries it.
+ *
+ * Note: Payload pre-parses the request body, so the signature is verified against a
+ * re-serialized payload rather than the original bytes — unavoidable at the endpoint layer.
+ */ export const muxWebhookHandler = (mux, pluginOptions)=>async (req)=>{
+        if (!req.json) return Response.json({
+            error: 'Bad request.'
+        }, {
+            status: 400
+        });
+        const body = await req.json();
+        if (!body) return Response.json({
+            error: 'Bad request.'
+        }, {
+            status: 400
+        });
+        let event;
+        try {
+            event = await mux.webhooks.unwrap(JSON.stringify(body), req.headers);
+        } catch (err) {
+            const hint = 'check that MUX_WEBHOOK_SECRET matches the signing secret in the Mux dashboard';
+            req.payload.logger.error({
+                err,
+                msg: `[payload-mux] Webhook signature verification failed — ${hint}`
+            });
+            return Response.json({
+                error: `Invalid signature — ${hint}.`
+            }, {
+                status: 401
+            });
+        }
+        if (!verifiedLogged) {
+            verifiedLogged = true;
+            req.payload.logger.info('[payload-mux] webhook verified — receiving Mux events');
+        }
+        const collection = pluginOptions.extendCollection ?? 'mux-video';
+        const assetId = event.object.id;
+        const videos = await req.payload.find({
+            collection,
+            where: {
+                assetId: {
+                    equals: assetId
+                }
+            },
+            limit: 1,
+            pagination: false
+        });
+        const video = videos.totalDocs > 0 ? videos.docs[0] : null;
+        if (!video) {
+            const backfillable = event.type === 'video.asset.created' || event.type === 'video.asset.ready' || event.type === 'video.asset.updated';
+            if (pluginOptions.autoCreateOnWebhook && backfillable) {
+                try {
+                    const title = event.data.meta?.title || assetId;
+                    const metadata = getAssetMetadata(event.data);
+                    const status = metadata.playbackOptions?.length ? 'ready' : 'preparing';
+                    await req.payload.create({
+                        collection,
+                        data: {
+                            title,
+                            assetId,
+                            ...metadata,
+                            status
+                        }
+                    });
+                } catch (err) {
+                    req.payload.logger.error({
+                        err,
+                        msg: `[payload-mux] Failed to backfill asset '${assetId}'`
+                    });
+                    return fail();
+                }
+            }
+            return ok();
+        }
+        try {
+            switch(event.type){
+                case 'video.asset.ready':
+                case 'video.asset.updated':
+                    {
+                        const metadata = getAssetMetadata(event.data);
+                        // `updated` can fire before a playback id exists — only playback-bearing events mean 'ready'.
+                        const status = metadata.playbackOptions?.length ? {
+                            status: 'ready',
+                            error: null
+                        } : {};
+                        await req.payload.update({
+                            collection,
+                            id: video.id,
+                            data: {
+                                ...metadata,
+                                ...status
+                            }
+                        });
+                        break;
+                    }
+                case 'video.asset.deleted':
+                    await req.payload.delete({
+                        collection,
+                        id: video.id
+                    });
+                    break;
+                case 'video.asset.errored':
+                    {
+                        req.payload.logger.error({
+                            assetId,
+                            errors: event.data.errors,
+                            msg: '[payload-mux] Asset errored'
+                        });
+                        const error = event.data.errors?.messages?.join('; ') || event.data.errors?.type || 'Unknown Mux error';
+                        await req.payload.update({
+                            collection,
+                            id: video.id,
+                            data: {
+                                status: 'errored',
+                                error
+                            }
+                        });
+                        break;
+                    }
+                default:
+                    break;
+            }
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: `[payload-mux] Failed to handle '${event.type}' for asset '${assetId}'`
+            });
+            return fail();
+        }
+        return ok();
+    };
+
+//# sourceMappingURL=webhook.js.map

package/dist/endpoints/webhook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/webhook.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { CollectionSlug, PayloadHandler } from 'payload'\nimport { type AssetLike, getAssetMetadata } from '../lib/getAssetMetadata'\nimport type { MuxVideoPluginOptions } from '../types'\n\nconst ok = () => new Response('Success!', { status: 200 })\nconst fail = () => new Response('Error', { status: 500 })\n\n// One info line per process so users can confirm the webhook wiring end to end.\nlet verifiedLogged = false\n\n/**\n * `POST /api/mux/webhook` — keep Payload in sync with Mux. `unwrap()` verifies the Mux\n * signature and returns a typed event; we then set metadata + status on `video.asset.ready` /\n * `updated`, delete the doc on `video.asset.deleted`, mark the doc errored on\n * `video.asset.errored`, and (when `autoCreateOnWebhook`) backfill a doc for an asset Payload\n * doesn't have yet. 200s after a handled event so Mux stops retrying; 500s on a failed\n * handler so Mux retries it.\n *\n * Note: Payload pre-parses the request body, so the signature is verified against a\n * re-serialized payload rather than the original bytes — unavoidable at the endpoint layer.\n */\nexport const muxWebhookHandler =\n  (mux: Mux, pluginOptions: MuxVideoPluginOptions): PayloadHandler =>\n  async (req) => {\n    if (!req.json) return Response.json({ error: 'Bad request.' }, { status: 400 })\n\n    const body = await req.json()\n    if (!body) return Response.json({ error: 'Bad request.' }, { status: 400 })\n\n    let event: Awaited<ReturnType<typeof mux.webhooks.unwrap>>\n    try {\n      event = await mux.webhooks.unwrap(JSON.stringify(body), req.headers)\n    } catch (err) {\n      const hint = 'check that MUX_WEBHOOK_SECRET matches the signing secret in the Mux dashboard'\n      req.payload.logger.error({ err, msg: `[payload-mux] Webhook signature verification failed — ${hint}` })\n      return Response.json({ error: `Invalid signature — ${hint}.` }, { status: 401 })\n    }\n\n    if (!verifiedLogged) {\n      verifiedLogged = true\n      req.payload.logger.info('[payload-mux] webhook verified — receiving Mux events')\n    }\n\n    const collection = ((pluginOptions.extendCollection as string) ?? 'mux-video') as CollectionSlug\n    const assetId = event.object.id\n\n    const videos = await req.payload.find({ collection, where: { assetId: { equals: assetId } }, limit: 1, pagination: false })\n    const video = videos.totalDocs > 0 ? videos.docs[0] : null\n\n    if (!video) {\n      const backfillable = event.type === 'video.asset.created' || event.type === 'video.asset.ready' || event.type === 'video.asset.updated'\n      if (pluginOptions.autoCreateOnWebhook && backfillable) {\n        try {\n          const title = (event.data as { meta?: { title?: string } }).meta?.title || assetId\n          const metadata = getAssetMetadata(event.data as AssetLike)\n          const status = metadata.playbackOptions?.length ? 'ready' : 'preparing'\n          await req.payload.create({ collection, data: { title, assetId, ...metadata, status } as never })\n        } catch (err) {\n          req.payload.logger.error({ err, msg: `[payload-mux] Failed to backfill asset '${assetId}'` })\n          return fail()\n        }\n      }\n      return ok()\n    }\n\n    try {\n      switch (event.type) {\n        case 'video.asset.ready':\n        case 'video.asset.updated': {\n          const metadata = getAssetMetadata(event.data)\n          // `updated` can fire before a playback id exists — only playback-bearing events mean 'ready'.\n          const status = metadata.playbackOptions?.length ? { status: 'ready', error: null } : {}\n          await req.payload.update({ collection, id: video.id, data: { ...metadata, ...status } as never })\n          break\n        }\n        case 'video.asset.deleted':\n          await req.payload.delete({ collection, id: video.id })\n          break\n        case 'video.asset.errored': {\n          req.payload.logger.error({ assetId, errors: event.data.errors, msg: '[payload-mux] Asset errored' })\n          const error = event.data.errors?.messages?.join('; ') || event.data.errors?.type || 'Unknown Mux error'\n          await req.payload.update({ collection, id: video.id, data: { status: 'errored', error } as never })\n          break\n        }\n        default:\n          break\n      }\n    } catch (err) {\n      req.payload.logger.error({ err, msg: `[payload-mux] Failed to handle '${event.type}' for asset '${assetId}'` })\n      return fail()\n    }\n\n    return ok()\n  }\n"],"names":["getAssetMetadata","ok","Response","status","fail","verifiedLogged","muxWebhookHandler","mux","pluginOptions","req","json","error","body","event","webhooks","unwrap","JSON","stringify","headers","err","hint","payload","logger","msg","info","collection","extendCollection","assetId","object","id","videos","find","where","equals","limit","pagination","video","totalDocs","docs","backfillable","type","autoCreateOnWebhook","title","data","meta","metadata","playbackOptions","length","create","update","delete","errors","messages","join"],"mappings":"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"}

package/dist/hooks/afterDelete.d.ts

@@ -0,0 +1,6 @@
+import type Mux from '@mux/mux-node';
+import type { CollectionAfterDeleteHook } from 'payload';
+/** When a video doc is deleted in Payload, delete its asset in Mux too. If the asset was
+ *  already removed in Mux (a `not_found`), that's fine — nothing to do. */
+export declare const getAfterDeleteHook: (mux: Mux) => CollectionAfterDeleteHook;
+//# sourceMappingURL=afterDelete.d.ts.map

package/dist/hooks/afterDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterDelete.d.ts","sourceRoot":"","sources":["../../src/hooks/afterDelete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAExD;2EAC2E;AAC3E,eAAO,MAAM,kBAAkB,GAC5B,KAAK,GAAG,KAAG,yBAUX,CAAA"}

package/dist/hooks/afterDelete.js

@@ -0,0 +1,12 @@
+/** When a video doc is deleted in Payload, delete its asset in Mux too. If the asset was
+ *  already removed in Mux (a `not_found`), that's fine — nothing to do. */ export const getAfterDeleteHook = (mux)=>async ({ doc })=>{
+        const assetId = doc.assetId;
+        if (!assetId) return;
+        try {
+            await mux.video.assets.delete(assetId);
+        } catch (err) {
+            if (err.type !== 'not_found') throw err;
+        }
+    };
+
+//# sourceMappingURL=afterDelete.js.map

package/dist/hooks/afterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/afterDelete.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { CollectionAfterDeleteHook } from 'payload'\n\n/** When a video doc is deleted in Payload, delete its asset in Mux too. If the asset was\n *  already removed in Mux (a `not_found`), that's fine — nothing to do. */\nexport const getAfterDeleteHook =\n  (mux: Mux): CollectionAfterDeleteHook =>\n  async ({ doc }) => {\n    const assetId = (doc as { assetId?: string }).assetId\n    if (!assetId) return\n\n    try {\n      await mux.video.assets.delete(assetId)\n    } catch (err) {\n      if ((err as { type?: string }).type !== 'not_found') throw err\n    }\n  }\n"],"names":["getAfterDeleteHook","mux","doc","assetId","video","assets","delete","err","type"],"mappings":"AAGA;yEACyE,GACzE,OAAO,MAAMA,qBACX,CAACC,MACD,OAAO,EAAEC,GAAG,EAAE;QACZ,MAAMC,UAAU,AAACD,IAA6BC,OAAO;QACrD,IAAI,CAACA,SAAS;QAEd,IAAI;YACF,MAAMF,IAAIG,KAAK,CAACC,MAAM,CAACC,MAAM,CAACH;QAChC,EAAE,OAAOI,KAAK;YACZ,IAAI,AAACA,IAA0BC,IAAI,KAAK,aAAa,MAAMD;QAC7D;IACF,EAAC"}

package/dist/hooks/beforeChange.d.ts

@@ -0,0 +1,11 @@
+import type Mux from '@mux/mux-node';
+import type { CollectionBeforeChangeHook } from 'payload';
+/**
+ * When a doc's `assetId` is set or changed: delete the previous asset (on update), fetch the
+ * new asset, briefly poll while it's `preparing`, and fold its metadata + `status` into the
+ * doc. A still-`preparing` asset is left for the webhook to finish; an `errored` asset is deleted
+ * and the save rejected. The doc's `filename`/`title` are made unique (the upload collection
+ * requires a unique filename).
+ */
+export declare const getBeforeChangeHook: (mux: Mux) => CollectionBeforeChangeHook;
+//# sourceMappingURL=beforeChange.d.ts.map

package/dist/hooks/beforeChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beforeChange.d.ts","sourceRoot":"","sources":["../../src/hooks/beforeChange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAE,0BAA0B,EAAkB,MAAM,SAAS,CAAA;AAQzE;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC7B,KAAK,GAAG,KAAG,0BA+DX,CAAA"}

package/dist/hooks/beforeChange.js

@@ -0,0 +1,95 @@
+import { delay } from "../lib/delay.js";
+import { getAssetMetadata } from "../lib/getAssetMetadata.js";
+/** Poll a freshly-uploaded asset for up to this long before handing off to the webhook. */ const POLL_INTERVAL_MS = 1500;
+const POLL_LIMIT_MS = 6000;
+/**
+ * When a doc's `assetId` is set or changed: delete the previous asset (on update), fetch the
+ * new asset, briefly poll while it's `preparing`, and fold its metadata + `status` into the
+ * doc. A still-`preparing` asset is left for the webhook to finish; an `errored` asset is deleted
+ * and the save rejected. The doc's `filename`/`title` are made unique (the upload collection
+ * requires a unique filename).
+ */ export const getBeforeChangeHook = (mux)=>async ({ req, data: incomingData, operation, originalDoc, collection })=>{
+        let data = {
+            ...incomingData
+        };
+        const previousAssetId = originalDoc?.assetId;
+        // Pre-resolved data (seed / import / webhook backfill): the doc already carries its
+        // assetId and playback options, so there's nothing to fetch from Mux. Pass it through.
+        if (data.assetId && Array.isArray(data.playbackOptions) && data.playbackOptions.length > 0) return data;
+        if (previousAssetId === data.assetId) return data;
+        try {
+            if (operation === 'update' && previousAssetId) {
+                await mux.video.assets.delete(previousAssetId);
+            }
+            let asset = await mux.video.assets.retrieve(data.assetId);
+            const timeout = Date.now() + POLL_LIMIT_MS;
+            while(asset.status === 'preparing' && Date.now() < timeout){
+                await delay(POLL_INTERVAL_MS);
+                asset = await mux.video.assets.retrieve(data.assetId);
+            }
+            if (asset.status === 'errored') {
+                await mux.video.assets.delete(data.assetId);
+                throw new Error(`Unable to prepare Mux asset (status: ${asset.status}). It's been deleted, please try again.`);
+            }
+            if (asset.status === 'ready') {
+                data = {
+                    ...data,
+                    ...getAssetMetadata(asset),
+                    status: 'ready',
+                    error: null
+                };
+            } else {
+                // Still preparing after the short poll — the webhook flips the status to 'ready'.
+                data = {
+                    ...data,
+                    status: 'preparing',
+                    error: null
+                };
+            }
+            // `title` is unique: probe `base`, then `base (1)`, `base (2)` … until one is free.
+            // Exact-match probing avoids counting unrelated titles, and excluding the current doc
+            // (on update) keeps a replace-the-video save from renaming itself.
+            const base = data.title;
+            let uniqueTitle = base;
+            for(let n = 1;; n++){
+                const titleClause = {
+                    title: {
+                        equals: uniqueTitle
+                    }
+                };
+                const where = operation === 'update' && originalDoc?.id != null ? {
+                    and: [
+                        titleClause,
+                        {
+                            id: {
+                                not_equals: originalDoc.id
+                            }
+                        }
+                    ]
+                } : titleClause;
+                const { totalDocs } = await req.payload.count({
+                    collection: collection.slug,
+                    where
+                });
+                if (totalDocs === 0) break;
+                uniqueTitle = `${base} (${n})`;
+            }
+            data.title = uniqueTitle;
+            // When extending an actual upload collection, the Mux asset stands in for the file: blank
+            // the url and mirror the unique title onto the (required, unique) filename. No-op for the
+            // default `mux-video` collection, which is not an upload collection and has neither field.
+            if (collection.upload) {
+                data.url = '';
+                data.filename = uniqueTitle;
+            }
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: `[payload-mux] Error preparing Mux asset for '${data.filename ?? data.title}'`
+            });
+            throw err;
+        }
+        return data;
+    };
+
+//# sourceMappingURL=beforeChange.js.map

package/dist/hooks/beforeChange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/beforeChange.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { CollectionBeforeChangeHook, CollectionSlug } from 'payload'\nimport { delay } from '../lib/delay'\nimport { getAssetMetadata } from '../lib/getAssetMetadata'\n\n/** Poll a freshly-uploaded asset for up to this long before handing off to the webhook. */\nconst POLL_INTERVAL_MS = 1500\nconst POLL_LIMIT_MS = 6000\n\n/**\n * When a doc's `assetId` is set or changed: delete the previous asset (on update), fetch the\n * new asset, briefly poll while it's `preparing`, and fold its metadata + `status` into the\n * doc. A still-`preparing` asset is left for the webhook to finish; an `errored` asset is deleted\n * and the save rejected. The doc's `filename`/`title` are made unique (the upload collection\n * requires a unique filename).\n */\nexport const getBeforeChangeHook =\n  (mux: Mux): CollectionBeforeChangeHook =>\n  async ({ req, data: incomingData, operation, originalDoc, collection }) => {\n    let data = { ...incomingData }\n    const previousAssetId: string | undefined = originalDoc?.assetId\n\n    // Pre-resolved data (seed / import / webhook backfill): the doc already carries its\n    // assetId and playback options, so there's nothing to fetch from Mux. Pass it through.\n    if (data.assetId && Array.isArray(data.playbackOptions) && data.playbackOptions.length > 0) return data\n\n    if (previousAssetId === data.assetId) return data\n\n    try {\n      if (operation === 'update' && previousAssetId) {\n        await mux.video.assets.delete(previousAssetId)\n      }\n\n      let asset = await mux.video.assets.retrieve(data.assetId)\n      const timeout = Date.now() + POLL_LIMIT_MS\n      while (asset.status === 'preparing' && Date.now() < timeout) {\n        await delay(POLL_INTERVAL_MS)\n        asset = await mux.video.assets.retrieve(data.assetId)\n      }\n\n      if (asset.status === 'errored') {\n        await mux.video.assets.delete(data.assetId)\n        throw new Error(`Unable to prepare Mux asset (status: ${asset.status}). It's been deleted, please try again.`)\n      }\n\n      if (asset.status === 'ready') {\n        data = { ...data, ...getAssetMetadata(asset), status: 'ready', error: null }\n      } else {\n        // Still preparing after the short poll — the webhook flips the status to 'ready'.\n        data = { ...data, status: 'preparing', error: null }\n      }\n\n      // `title` is unique: probe `base`, then `base (1)`, `base (2)` … until one is free.\n      // Exact-match probing avoids counting unrelated titles, and excluding the current doc\n      // (on update) keeps a replace-the-video save from renaming itself.\n      const base = data.title as string\n      let uniqueTitle = base\n      for (let n = 1; ; n++) {\n        const titleClause = { title: { equals: uniqueTitle } }\n        const where =\n          operation === 'update' && originalDoc?.id != null ? { and: [titleClause, { id: { not_equals: originalDoc.id } }] } : titleClause\n        const { totalDocs } = await req.payload.count({ collection: collection.slug as CollectionSlug, where })\n        if (totalDocs === 0) break\n        uniqueTitle = `${base} (${n})`\n      }\n      data.title = uniqueTitle\n\n      // When extending an actual upload collection, the Mux asset stands in for the file: blank\n      // the url and mirror the unique title onto the (required, unique) filename. No-op for the\n      // default `mux-video` collection, which is not an upload collection and has neither field.\n      if (collection.upload) {\n        data.url = ''\n        data.filename = uniqueTitle\n      }\n    } catch (err) {\n      req.payload.logger.error({ err, msg: `[payload-mux] Error preparing Mux asset for '${data.filename ?? data.title}'` })\n      throw err\n    }\n\n    return data\n  }\n"],"names":["delay","getAssetMetadata","POLL_INTERVAL_MS","POLL_LIMIT_MS","getBeforeChangeHook","mux","req","data","incomingData","operation","originalDoc","collection","previousAssetId","assetId","Array","isArray","playbackOptions","length","video","assets","delete","asset","retrieve","timeout","Date","now","status","Error","error","base","title","uniqueTitle","n","titleClause","equals","where","id","and","not_equals","totalDocs","payload","count","slug","upload","url","filename","err","logger","msg"],"mappings":"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"}

package/dist/hooks/beforeValidate.d.ts

@@ -0,0 +1,17 @@
+import type Mux from '@mux/mux-node';
+import type { CollectionBeforeValidateHook } from 'payload';
+import type { MuxVideoPluginOptions } from '../types';
+/**
+ * Server-side ingest. When a doc is created (or updated) with a transient `source` (a local
+ * path or `http(s)` URL) and no `assetId` yet, upload it to Mux, wait until the asset is
+ * `ready`, and fold the asset id + metadata into the doc — running in `beforeValidate` so it
+ * lands before `assetId`'s required check. The `source` key is always stripped so it never
+ * persists. Docs that already carry an `assetId` (the admin direct-upload flow, webhook
+ * backfill, or pre-resolved seed data) skip ingest entirely.
+ *
+ * Playback policy (and the rest of `new_asset_settings`) come from the plugin's `uploadSettings`
+ * — the same config the admin direct-upload path uses — so a seeded video matches an admin-uploaded
+ * one. A per-video `source.playbackPolicy` overrides it.
+ */
+export declare const getBeforeValidateHook: (mux: Mux, options?: MuxVideoPluginOptions) => CollectionBeforeValidateHook;
+//# sourceMappingURL=beforeValidate.d.ts.map

package/dist/hooks/beforeValidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beforeValidate.d.ts","sourceRoot":"","sources":["../../src/hooks/beforeValidate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,eAAe,CAAA;AACpC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAA;AAG3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AA6BrD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAC/B,KAAK,GAAG,EAAE,UAAS,qBAA0B,KAAG,4BA0BhD,CAAA"}

package/dist/hooks/beforeValidate.js

@@ -0,0 +1,61 @@
+import { getAssetMetadata } from "../lib/getAssetMetadata.js";
+import { ingestMuxAsset } from "../lib/ingest.js";
+/** Normalize a `source` value (string or object) to a ref + options, or null if unusable. */ function normalizeSource(source) {
+    if (!source) return null;
+    if (typeof source === 'string') return {
+        ref: source
+    };
+    const s = source;
+    const ref = s.url ?? s.file;
+    if (!ref) return null;
+    return {
+        ref,
+        playbackPolicy: s.playbackPolicy,
+        corsOrigin: s.corsOrigin,
+        posterTimestamp: s.posterTimestamp
+    };
+}
+/**
+ * Server-side ingest. When a doc is created (or updated) with a transient `source` (a local
+ * path or `http(s)` URL) and no `assetId` yet, upload it to Mux, wait until the asset is
+ * `ready`, and fold the asset id + metadata into the doc — running in `beforeValidate` so it
+ * lands before `assetId`'s required check. The `source` key is always stripped so it never
+ * persists. Docs that already carry an `assetId` (the admin direct-upload flow, webhook
+ * backfill, or pre-resolved seed data) skip ingest entirely.
+ *
+ * Playback policy (and the rest of `new_asset_settings`) come from the plugin's `uploadSettings`
+ * — the same config the admin direct-upload path uses — so a seeded video matches an admin-uploaded
+ * one. A per-video `source.playbackPolicy` overrides it.
+ */ export const getBeforeValidateHook = (mux, options = {})=>async ({ data })=>{
+        const d = data ?? {};
+        if (!('source' in d)) return data;
+        const { source, ...rest } = d;
+        const norm = d.assetId ? null : normalizeSource(source);
+        if (!norm) return rest;
+        const asset = await ingestMuxAsset(mux, norm.ref, {
+            // Mirror the admin direct-upload path (`upload.ts`): the plugin-level `playbackPolicy`
+            // shorthand is the base default, overlaid by the full `uploadSettings.new_asset_settings`,
+            // with a per-video `source.playbackPolicy` winning last — so seeded and admin-uploaded
+            // videos share one policy.
+            newAssetSettings: {
+                playback_policy: [
+                    options.playbackPolicy ?? 'public'
+                ],
+                ...options.uploadSettings?.new_asset_settings
+            },
+            playbackPolicy: norm.playbackPolicy,
+            corsOrigin: norm.corsOrigin ?? options.uploadSettings?.cors_origin
+        });
+        return {
+            ...rest,
+            assetId: asset.id,
+            ...getAssetMetadata(asset),
+            // Ingest waits until the asset is ready, so the status can be stamped directly.
+            status: 'ready',
+            ...norm.posterTimestamp !== undefined ? {
+                posterTimestamp: norm.posterTimestamp
+            } : {}
+        };
+    };
+
+//# sourceMappingURL=beforeValidate.js.map

package/dist/hooks/beforeValidate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/beforeValidate.ts"],"sourcesContent":["import type Mux from '@mux/mux-node'\nimport type { CollectionBeforeValidateHook } from 'payload'\nimport { getAssetMetadata } from '../lib/getAssetMetadata'\nimport { ingestMuxAsset, type MuxSource } from '../lib/ingest'\nimport type { MuxVideoPluginOptions } from '../types'\n\n/** The transient `source` a caller sets to ingest server-side: a string path/URL, or an\n *  object carrying the path/URL plus per-video options. Never persisted. */\ninterface MuxSourceInput {\n  file?: string\n  url?: string\n  playbackPolicy?: 'public' | 'signed'\n  posterTimestamp?: number\n  corsOrigin?: string\n}\n\ninterface NormalizedSource {\n  ref: MuxSource\n  playbackPolicy?: 'public' | 'signed'\n  corsOrigin?: string\n  posterTimestamp?: number\n}\n\n/** Normalize a `source` value (string or object) to a ref + options, or null if unusable. */\nfunction normalizeSource(source: unknown): NormalizedSource | null {\n  if (!source) return null\n  if (typeof source === 'string') return { ref: source }\n  const s = source as MuxSourceInput\n  const ref = s.url ?? s.file\n  if (!ref) return null\n  return { ref, playbackPolicy: s.playbackPolicy, corsOrigin: s.corsOrigin, posterTimestamp: s.posterTimestamp }\n}\n\n/**\n * Server-side ingest. When a doc is created (or updated) with a transient `source` (a local\n * path or `http(s)` URL) and no `assetId` yet, upload it to Mux, wait until the asset is\n * `ready`, and fold the asset id + metadata into the doc — running in `beforeValidate` so it\n * lands before `assetId`'s required check. The `source` key is always stripped so it never\n * persists. Docs that already carry an `assetId` (the admin direct-upload flow, webhook\n * backfill, or pre-resolved seed data) skip ingest entirely.\n *\n * Playback policy (and the rest of `new_asset_settings`) come from the plugin's `uploadSettings`\n * — the same config the admin direct-upload path uses — so a seeded video matches an admin-uploaded\n * one. A per-video `source.playbackPolicy` overrides it.\n */\nexport const getBeforeValidateHook =\n  (mux: Mux, options: MuxVideoPluginOptions = {}): CollectionBeforeValidateHook =>\n  async ({ data }) => {\n    const d = (data ?? {}) as Record<string, unknown>\n    if (!('source' in d)) return data\n\n    const { source, ...rest } = d\n    const norm = d.assetId ? null : normalizeSource(source)\n    if (!norm) return rest\n\n    const asset = await ingestMuxAsset(mux, norm.ref, {\n      // Mirror the admin direct-upload path (`upload.ts`): the plugin-level `playbackPolicy`\n      // shorthand is the base default, overlaid by the full `uploadSettings.new_asset_settings`,\n      // with a per-video `source.playbackPolicy` winning last — so seeded and admin-uploaded\n      // videos share one policy.\n      newAssetSettings: { playback_policy: [options.playbackPolicy ?? 'public'], ...options.uploadSettings?.new_asset_settings },\n      playbackPolicy: norm.playbackPolicy,\n      corsOrigin: norm.corsOrigin ?? options.uploadSettings?.cors_origin,\n    })\n    return {\n      ...rest,\n      assetId: asset.id,\n      ...getAssetMetadata(asset),\n      // Ingest waits until the asset is ready, so the status can be stamped directly.\n      status: 'ready',\n      ...(norm.posterTimestamp !== undefined ? { posterTimestamp: norm.posterTimestamp } : {}),\n    }\n  }\n"],"names":["getAssetMetadata","ingestMuxAsset","normalizeSource","source","ref","s","url","file","playbackPolicy","corsOrigin","posterTimestamp","getBeforeValidateHook","mux","options","data","d","rest","norm","assetId","asset","newAssetSettings","playback_policy","uploadSettings","new_asset_settings","cors_origin","id","status","undefined"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,6BAAyB;AAC1D,SAASC,cAAc,QAAwB,mBAAe;AAoB9D,2FAA2F,GAC3F,SAASC,gBAAgBC,MAAe;IACtC,IAAI,CAACA,QAAQ,OAAO;IACpB,IAAI,OAAOA,WAAW,UAAU,OAAO;QAAEC,KAAKD;IAAO;IACrD,MAAME,IAAIF;IACV,MAAMC,MAAMC,EAAEC,GAAG,IAAID,EAAEE,IAAI;IAC3B,IAAI,CAACH,KAAK,OAAO;IACjB,OAAO;QAAEA;QAAKI,gBAAgBH,EAAEG,cAAc;QAAEC,YAAYJ,EAAEI,UAAU;QAAEC,iBAAiBL,EAAEK,eAAe;IAAC;AAC/G;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,wBACX,CAACC,KAAUC,UAAiC,CAAC,CAAC,GAC9C,OAAO,EAAEC,IAAI,EAAE;QACb,MAAMC,IAAKD,QAAQ,CAAC;QACpB,IAAI,CAAE,CAAA,YAAYC,CAAAA,GAAI,OAAOD;QAE7B,MAAM,EAAEX,MAAM,EAAE,GAAGa,MAAM,GAAGD;QAC5B,MAAME,OAAOF,EAAEG,OAAO,GAAG,OAAOhB,gBAAgBC;QAChD,IAAI,CAACc,MAAM,OAAOD;QAElB,MAAMG,QAAQ,MAAMlB,eAAeW,KAAKK,KAAKb,GAAG,EAAE;YAChD,uFAAuF;YACvF,2FAA2F;YAC3F,uFAAuF;YACvF,2BAA2B;YAC3BgB,kBAAkB;gBAAEC,iBAAiB;oBAACR,QAAQL,cAAc,IAAI;iBAAS;gBAAE,GAAGK,QAAQS,cAAc,EAAEC,kBAAkB;YAAC;YACzHf,gBAAgBS,KAAKT,cAAc;YACnCC,YAAYQ,KAAKR,UAAU,IAAII,QAAQS,cAAc,EAAEE;QACzD;QACA,OAAO;YACL,GAAGR,IAAI;YACPE,SAASC,MAAMM,EAAE;YACjB,GAAGzB,iBAAiBmB,MAAM;YAC1B,gFAAgF;YAChFO,QAAQ;YACR,GAAIT,KAAKP,eAAe,KAAKiB,YAAY;gBAAEjB,iBAAiBO,KAAKP,eAAe;YAAC,IAAI,CAAC,CAAC;QACzF;IACF,EAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { muxVideoPlugin } from './plugin';
+export { MuxVideo } from './collections/MuxVideo';
+export { ingestMuxVideo } from './lib/ingest';
+export type { IngestMuxVideoOptions } from './lib/ingest';
+export type { MuxVideoInitSettings, MuxVideoNewAssetSettings, MuxVideoPluginOptions, MuxVideoSignedUrlOptions, MuxVideoUploadSettings, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAGzC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAGjD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,YAAY,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAGzD,YAAY,EACV,oBAAoB,EACpB,wBAAwB,EACxB,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// The plugin
+export { muxVideoPlugin } from "./plugin.js";
+// The collection factory, for advanced consumers assembling their own config
+export { MuxVideo } from "./collections/MuxVideo.js";
+// Server-side ingest — create a mux-video from a local file / URL (seeding, imports, migrations)
+export { ingestMuxVideo } from "./lib/ingest.js";
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// The plugin\nexport { muxVideoPlugin } from './plugin'\n\n// The collection factory, for advanced consumers assembling their own config\nexport { MuxVideo } from './collections/MuxVideo'\n\n// Server-side ingest — create a mux-video from a local file / URL (seeding, imports, migrations)\nexport { ingestMuxVideo } from './lib/ingest'\nexport type { IngestMuxVideoOptions } from './lib/ingest'\n\n// Types\nexport type {\n  MuxVideoInitSettings,\n  MuxVideoNewAssetSettings,\n  MuxVideoPluginOptions,\n  MuxVideoSignedUrlOptions,\n  MuxVideoUploadSettings,\n} from './types'\n"],"names":["muxVideoPlugin","MuxVideo","ingestMuxVideo"],"mappings":"AAAA,aAAa;AACb,SAASA,cAAc,QAAQ,cAAU;AAEzC,6EAA6E;AAC7E,SAASC,QAAQ,QAAQ,4BAAwB;AAEjD,iGAAiG;AACjG,SAASC,cAAc,QAAQ,kBAAc"}

package/dist/lib/defaultAccess.d.ts

@@ -0,0 +1,5 @@
+import type { PayloadRequest } from 'payload';
+/** Default upload/read gate: allow only a logged-in user from the configured admin
+ *  collection. Override per-plugin via the `access` option. */
+export declare const defaultAccess: (req: PayloadRequest) => boolean;
+//# sourceMappingURL=defaultAccess.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultAccess.d.ts","sourceRoot":"","sources":["../../src/lib/defaultAccess.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;+DAC+D;AAC/D,eAAO,MAAM,aAAa,GAAI,KAAK,cAAc,KAAG,OAAqF,CAAA"}

package/dist/lib/defaultAccess.js

@@ -0,0 +1,4 @@
+/** Default upload/read gate: allow only a logged-in user from the configured admin
+ *  collection. Override per-plugin via the `access` option. */ export const defaultAccess = (req)=>Boolean(req.user && req.user.collection === req.payload.config.admin.user);
+
+//# sourceMappingURL=defaultAccess.js.map

package/dist/lib/defaultAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/defaultAccess.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\n/** Default upload/read gate: allow only a logged-in user from the configured admin\n *  collection. Override per-plugin via the `access` option. */\nexport const defaultAccess = (req: PayloadRequest): boolean => Boolean(req.user && req.user.collection === req.payload.config.admin.user)\n"],"names":["defaultAccess","req","Boolean","user","collection","payload","config","admin"],"mappings":"AAEA;6DAC6D,GAC7D,OAAO,MAAMA,gBAAgB,CAACC,MAAiCC,QAAQD,IAAIE,IAAI,IAAIF,IAAIE,IAAI,CAACC,UAAU,KAAKH,IAAII,OAAO,CAACC,MAAM,CAACC,KAAK,CAACJ,IAAI,EAAC"}

package/dist/lib/delay.d.ts

@@ -0,0 +1,3 @@
+/** Resolve after `ms` milliseconds. */
+export declare const delay: (ms: number) => Promise<void>;
+//# sourceMappingURL=delay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../src/lib/delay.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAAsD,CAAA"}

package/dist/lib/delay.js

@@ -0,0 +1,3 @@
+/** Resolve after `ms` milliseconds. */ export const delay = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+
+//# sourceMappingURL=delay.js.map

package/dist/lib/delay.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/delay.ts"],"sourcesContent":["/** Resolve after `ms` milliseconds. */\nexport const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))\n"],"names":["delay","ms","Promise","resolve","setTimeout"],"mappings":"AAAA,qCAAqC,GACrC,OAAO,MAAMA,QAAQ,CAACC,KAA8B,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF,KAAI"}