@x12i/youtube-video-uploader-cli 1.4.0 → 1.6.1

package/src/playlist/sync.js

@@ -0,0 +1,192 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { UploadState } from '../state.js';
+import { swapSong } from '../swap/swapSong.js';
+import { detectOutdatedUploads } from './detect-outdated.js';
+import { resolveDesiredPlaylistOrder } from './order.js';
+import {
+  listPlaylistItems,
+  playlistOrderMatches,
+  reorderPlaylist,
+} from './reorder.js';
+
+/**
+ * Sync a YouTube playlist with local files: push outdated uploads via swap,
+ * then realign playlist order. Keeps videos private by default.
+ *
+ * @param {object} options
+ * @param {import('googleapis').youtube_v3.Youtube} options.youtube
+ * @param {string} options.albumDir
+ * @param {string} options.playlistId
+ * @param {string} [options.overviewHistoryPath]
+ * @param {string[]} [options.overviewKeys]
+ * @param {string[]} [options.songKeys]
+ * @param {string[]} [options.onlyFilenames]
+ * @param {'preserve' | 'private' | 'public'} [options.privacyMode='private']
+ * @param {boolean} [options.dryRun=false]
+ * @param {boolean} [options.skipReorder=false]
+ * @param {boolean} [options.freshSwap=false]
+ * @param {string} [options.stateFile]
+ * @param {(event: object) => void} [options.onEvent]
+ * @returns {Promise<object>}
+ */
+export async function syncPlaylist(options = {}) {
+  const {
+    youtube,
+    albumDir,
+    playlistId,
+    overviewHistoryPath,
+    overviewKeys = [],
+    songKeys,
+    onlyFilenames,
+    privacyMode = 'private',
+    dryRun = false,
+    skipReorder = false,
+    freshSwap = false,
+    stateFile,
+    onEvent = () => {},
+  } = options;
+
+  if (!albumDir || !playlistId) {
+    throw new Error('syncPlaylist requires albumDir and playlistId');
+  }
+
+  const resolvedAlbumDir = path.resolve(albumDir);
+  const albumState = new UploadState(resolvedAlbumDir, stateFile);
+
+  const outdated = detectOutdatedUploads(resolvedAlbumDir, albumState, { onlyFilenames });
+  const desiredOrder = resolveDesiredPlaylistOrder({
+    albumDir: resolvedAlbumDir,
+    albumState,
+    overviewHistoryPath,
+    overviewKeys,
+    songKeys,
+  });
+
+  let currentOrder = [];
+  if (!dryRun && youtube) {
+    const currentItems = await listPlaylistItems(youtube, playlistId);
+    currentOrder = currentItems.map((item) => item.videoId);
+  }
+
+  const plan = {
+    playlistId,
+    albumDir: resolvedAlbumDir,
+    privacyMode,
+    outdated,
+    desiredOrder,
+    currentOrder,
+    orderAligned: currentOrder.length
+      ? playlistOrderMatches(currentOrder, desiredOrder)
+      : null,
+    swaps: outdated.map((item) => ({
+      filename: item.filename,
+      oldVideoId: item.videoId,
+      modifiedAt: item.modifiedAt,
+      uploadedAt: item.uploadedAt,
+    })),
+  };
+
+  onEvent({ type: 'sync_plan', plan });
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      ...plan,
+      pushed: [],
+      reordered: false,
+    };
+  }
+
+  if (!youtube) {
+    throw new Error('syncPlaylist requires an authorized youtube client when dryRun is false');
+  }
+
+  const pushed = [];
+  const failed = [];
+
+  for (const item of outdated) {
+    onEvent({ type: 'sync_push_start', filename: item.filename, oldVideoId: item.videoId });
+    try {
+      const { record } = await swapSong({
+        youtube,
+        songKey: item.filename,
+        newVideoPath: item.filePath,
+        playlistId,
+        oldVideoId: item.videoId,
+        stateDir: resolvedAlbumDir,
+        fresh: freshSwap,
+        privacyMode,
+        onEvent: (event) => onEvent({ ...event, filename: item.filename }),
+      });
+
+      albumState.data.uploads[item.filename] = {
+        ...albumState.data.uploads[item.filename],
+        videoId: record.newVideoId,
+        uploadedAt: new Date().toISOString(),
+        playlistId,
+        previousVideoId: item.videoId,
+      };
+      albumState.save();
+
+      pushed.push({
+        filename: item.filename,
+        oldVideoId: item.videoId,
+        newVideoId: record.newVideoId,
+        url: `https://youtu.be/${record.newVideoId}`,
+      });
+      onEvent({ type: 'sync_push_success', filename: item.filename, record });
+    } catch (err) {
+      failed.push({ filename: item.filename, error: err });
+      onEvent({ type: 'sync_push_error', filename: item.filename, error: err });
+      throw err;
+    }
+  }
+
+  const refreshedDesiredOrder = resolveDesiredPlaylistOrder({
+    albumDir: resolvedAlbumDir,
+    albumState,
+    overviewHistoryPath,
+    overviewKeys,
+    songKeys,
+  });
+
+  let reorderResult = { changed: 0, finalOrder: refreshedDesiredOrder };
+  if (!skipReorder) {
+    const latestItems = await listPlaylistItems(youtube, playlistId);
+    const latestOrder = latestItems.map((item) => item.videoId);
+    if (!playlistOrderMatches(latestOrder, refreshedDesiredOrder)) {
+      onEvent({ type: 'sync_reorder_start', desiredOrder: refreshedDesiredOrder });
+      reorderResult = await reorderPlaylist(youtube, playlistId, refreshedDesiredOrder);
+      onEvent({ type: 'sync_reorder_success', ...reorderResult });
+    }
+  }
+
+  if (overviewHistoryPath && overviewKeys.length > 0) {
+    const absOverviewHistory = path.resolve(overviewHistoryPath);
+    if (fs.existsSync(absOverviewHistory)) {
+      const overviewHistory = JSON.parse(fs.readFileSync(absOverviewHistory, 'utf-8'));
+      overviewHistory.playlistId = playlistId;
+      overviewHistory.playlistOrder = refreshedDesiredOrder;
+      overviewHistory.updatedAt = new Date().toISOString();
+      fs.writeFileSync(absOverviewHistory, JSON.stringify(overviewHistory, null, 2) + '\n');
+    }
+  }
+
+  albumState.data.playlistId = playlistId;
+  albumState.data.playlistOrder = refreshedDesiredOrder;
+  albumState.data.updatedAt = new Date().toISOString();
+  albumState.save();
+
+  return {
+    dryRun: false,
+    playlistId,
+    pushed,
+    failed,
+    outdated,
+    desiredOrder: refreshedDesiredOrder,
+    reordered: reorderResult.changed > 0,
+    reorderChanges: reorderResult.changed,
+    orderAligned: true,
+  };
+}

package/src/providers/watermark/index.js

@@ -0,0 +1,113 @@
+/**
+ * Watermark-remover provider registry.
+ *
+ * Only register tools with permissive open-source licenses:
+ * MIT, Apache-2.0, BSD-2-Clause, BSD-3-Clause, or ISC.
+ *
+ * To add another MIT/Apache/BSD/ISC npm CLI later:
+ * 1. Create `src/providers/watermark/<id>.js` with a `run*Remove` entry point
+ * 2. Register it in PROVIDERS below
+ * 3. No pipeline changes required
+ */
+
+import {
+  PILIO_PROVIDER_ID,
+  PILIO_LICENSE,
+  runPilioRemove,
+  formatPilioCommand,
+  buildPilioArgs,
+  resolvePilioBin,
+} from './pilio.js';
+
+/** @typedef {'MIT' | 'Apache-2.0' | 'BSD-2-Clause' | 'BSD-3-Clause' | 'ISC'} PermissiveLicense */
+
+/**
+ * @typedef {object} WatermarkProvider
+ * @property {string} id
+ * @property {PermissiveLicense} license
+ * @property {string} packageName
+ * @property {(options: object) => Promise<{ outputPath?: string, outDir?: string, dryRun?: boolean, command: string, exitCode?: number, stdout?: string }>} remove
+ */
+
+/** @type {Record<string, WatermarkProvider>} */
+const PROVIDERS = {
+  [PILIO_PROVIDER_ID]: {
+    id: PILIO_PROVIDER_ID,
+    license: PILIO_LICENSE,
+    packageName: '@pilio/gemini-watermark-remover',
+    remove: runPilioRemove,
+  },
+};
+
+export const DEFAULT_WATERMARK_PROVIDER = PILIO_PROVIDER_ID;
+
+export const PERMISSIVE_LICENSES = Object.freeze([
+  'MIT',
+  'Apache-2.0',
+  'BSD-2-Clause',
+  'BSD-3-Clause',
+  'ISC',
+]);
+
+/**
+ * List registered watermark providers.
+ * @returns {Array<{ id: string, license: string, packageName: string }>}
+ */
+export function listWatermarkProviders() {
+  return Object.values(PROVIDERS).map(({ id, license, packageName }) => ({
+    id,
+    license,
+    packageName,
+  }));
+}
+
+/**
+ * Resolve a watermark provider by id (default: pilio).
+ * @param {string} [providerId]
+ * @returns {WatermarkProvider}
+ */
+export function getWatermarkProvider(providerId = DEFAULT_WATERMARK_PROVIDER) {
+  const id = String(providerId || DEFAULT_WATERMARK_PROVIDER).trim().toLowerCase();
+  const provider = PROVIDERS[id];
+  if (!provider) {
+    const known = Object.keys(PROVIDERS).join(', ');
+    throw new Error(
+      `Unknown watermark provider "${providerId}". Known providers: ${known}. ` +
+      `Only permissive-license tools (${PERMISSIVE_LICENSES.join(', ')}) may be registered.`
+    );
+  }
+  if (!PERMISSIVE_LICENSES.includes(provider.license)) {
+    throw new Error(
+      `Watermark provider "${provider.id}" has disallowed license "${provider.license}". ` +
+      `Allowed: ${PERMISSIVE_LICENSES.join(', ')}.`
+    );
+  }
+  return provider;
+}
+
+/**
+ * Remove a Gemini/Veo visible watermark via the selected provider.
+ *
+ * @param {object} options
+ * @param {string} options.inputPath
+ * @param {string} [options.outputPath]
+ * @param {string} [options.outDir]
+ * @param {string} [options.provider]
+ * @param {boolean} [options.overwrite]
+ * @param {boolean} [options.json]
+ * @param {number} [options.videoBitrateMbps]
+ * @param {boolean} [options.dryRun]
+ * @param {(chunk: string) => void} [options.onStderr]
+ */
+export async function removeWatermarkWithProvider(options = {}) {
+  const provider = getWatermarkProvider(options.provider);
+  return provider.remove(options);
+}
+
+export {
+  runPilioRemove,
+  formatPilioCommand,
+  buildPilioArgs,
+  resolvePilioBin,
+  PILIO_PROVIDER_ID,
+};

package/src/providers/watermark/pilio.js

@@ -0,0 +1,201 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PILIO_PROVIDER_ID = 'pilio';
+export const PILIO_LICENSE = 'MIT';
+export const PILIO_PACKAGE = '@pilio/gemini-watermark-remover';
+
+/**
+ * Locate the installed package root and gwr binary path.
+ * @returns {{ root: string, binPath: string }}
+ */
+export function resolvePilioBin() {
+  let entryUrl;
+  try {
+    entryUrl = import.meta.resolve(PILIO_PACKAGE);
+  } catch (err) {
+    throw new Error(
+      `Watermark provider "${PILIO_PROVIDER_ID}" requires ${PILIO_PACKAGE} (license: ${PILIO_LICENSE}). ` +
+      `Install it with: npm install ${PILIO_PACKAGE} sharp\n` +
+      `Original error: ${err.message}`
+    );
+  }
+
+  const entryPath = fileURLToPath(entryUrl);
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (pkg.name === PILIO_PACKAGE) {
+          const binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.gwr;
+          if (!binRel) {
+            throw new Error(`${PILIO_PACKAGE} package.json is missing a "gwr" bin entry`);
+          }
+          const binPath = path.resolve(dir, binRel);
+          if (!fs.existsSync(binPath)) {
+            throw new Error(`gwr binary not found at ${binPath}`);
+          }
+          return { root: dir, binPath };
+        }
+      } catch (err) {
+        if (err.message.includes('gwr binary') || err.message.includes('bin entry')) {
+          throw err;
+        }
+      }
+    }
+    dir = path.dirname(dir);
+  }
+
+  throw new Error(
+    `Could not locate ${PILIO_PACKAGE} package root after resolving ${entryPath}. ` +
+    `Reinstall with: npm install ${PILIO_PACKAGE} sharp`
+  );
+}
+
+/**
+ * Build the gwr argv for a remove operation.
+ *
+ * @param {object} options
+ * @param {string} options.inputPath
+ * @param {string} [options.outputPath]
+ * @param {string} [options.outDir]
+ * @param {boolean} [options.overwrite=false]
+ * @param {boolean} [options.json=false]
+ * @param {number} [options.videoBitrateMbps]
+ * @returns {string[]}
+ */
+export function buildPilioArgs(options = {}) {
+  const {
+    inputPath,
+    outputPath,
+    outDir,
+    overwrite = false,
+    json = false,
+    videoBitrateMbps,
+  } = options;
+
+  if (!inputPath) {
+    throw new Error('inputPath is required for pilio watermark removal');
+  }
+
+  const args = ['remove', inputPath];
+
+  if (outDir) {
+    args.push('--out-dir', outDir);
+  } else if (outputPath) {
+    args.push('--output', outputPath);
+  } else {
+    throw new Error('Either outputPath or outDir is required for pilio watermark removal');
+  }
+
+  if (overwrite) {
+    args.push('--overwrite');
+  }
+  if (json) {
+    args.push('--json');
+  }
+  if (videoBitrateMbps !== undefined && videoBitrateMbps !== null && videoBitrateMbps !== '') {
+    const n = Number(videoBitrateMbps);
+    if (!Number.isFinite(n) || n <= 0) {
+      throw new Error(`Invalid videoBitrateMbps: ${videoBitrateMbps}`);
+    }
+    args.push('--video-bitrate-mbps', String(n));
+  }
+
+  return args;
+}
+
+/**
+ * Format a human-readable command string (for dry-run / logs).
+ *
+ * @param {string[]} args
+ * @param {string} [binPath='gwr']
+ * @returns {string}
+ */
+export function formatPilioCommand(args, binPath = 'gwr') {
+  const quote = (s) => (/\s/.test(s) ? JSON.stringify(s) : s);
+  return [quote(binPath), ...args.map(quote)].join(' ');
+}
+
+/**
+ * Run the pilio gwr CLI.
+ *
+ * @param {object} options
+ * @param {string} options.inputPath
+ * @param {string} [options.outputPath]
+ * @param {string} [options.outDir]
+ * @param {boolean} [options.overwrite=false]
+ * @param {boolean} [options.json=false]
+ * @param {number} [options.videoBitrateMbps]
+ * @param {boolean} [options.dryRun=false]
+ * @param {(chunk: string) => void} [options.onStderr]
+ * @returns {Promise<{ outputPath?: string, outDir?: string, dryRun?: boolean, command: string, exitCode?: number, stdout?: string }>}
+ */
+export async function runPilioRemove(options = {}) {
+  const { dryRun = false, onStderr } = options;
+  const { binPath } = resolvePilioBin();
+  const args = buildPilioArgs(options);
+  const command = formatPilioCommand(args, binPath);
+
+  if (dryRun) {
+    return {
+      outputPath: options.outputPath,
+      outDir: options.outDir,
+      dryRun: true,
+      command,
+    };
+  }
+
+  if (options.outputPath) {
+    fs.mkdirSync(path.dirname(path.resolve(options.outputPath)), { recursive: true });
+  }
+  if (options.outDir) {
+    fs.mkdirSync(path.resolve(options.outDir), { recursive: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [binPath, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (onStderr) onStderr(text);
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(
+        `Failed to execute watermark provider "${PILIO_PROVIDER_ID}" (${PILIO_PACKAGE}): ${err.message}`
+      ));
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        const detail = (stderr || stdout || '').trim() || `exit code ${code}`;
+        reject(new Error(
+          `Watermark provider "${PILIO_PROVIDER_ID}" failed for ${options.inputPath}: ${detail}`
+        ));
+        return;
+      }
+      resolve({
+        outputPath: options.outputPath,
+        outDir: options.outDir,
+        command,
+        exitCode: code,
+        stdout,
+      });
+    });
+  });
+}

package/src/swap/steps.js

@@ -8,10 +8,7 @@ import { uploadVideo } from '../uploader.js';
  */
 
 /**
- * Step 1 — Upload the new video as unlisted (never straight to public).
- *
- * Metadata (title/description/tags/category) is carried over from the old
- * video's snippet when available so the replacement stays continuous.
+ * Upload the new video for a playlist swap.
  *
  * @param {import('googleapis').youtube_v3.Youtube} youtube
  * @param {string} newVideoPath
@@ -19,6 +16,7 @@ import { uploadVideo } from '../uploader.js';
  * @param {string} [opts.oldVideoId] - Fetch old video's snippet to carry over
  * @param {object} [opts.meta] - Explicit metadata overrides
  * @param {number} [opts.retries=3]
+ * @param {'private' | 'unlisted' | 'public'} [opts.uploadPrivacy='unlisted']
  * @returns {Promise<{ videoId: string, url: string }>}
  */
 export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
@@ -26,12 +24,14 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
     throw new Error(`New video file not found: ${newVideoPath}`);
   }
 
+  const uploadPrivacy = opts.uploadPrivacy || opts.meta?.privacyStatus || 'unlisted';
+
   let meta = {
     title: opts.meta?.title,
     description: opts.meta?.description,
     tags: opts.meta?.tags,
     categoryId: opts.meta?.categoryId,
-    privacyStatus: 'unlisted',
+    privacyStatus: uploadPrivacy,
     selfDeclaredMadeForKids: opts.meta?.selfDeclaredMadeForKids ?? false,
   };
 
@@ -49,7 +49,7 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
           description: meta.description ?? old.snippet?.description,
           tags: meta.tags || old.snippet?.tags || [],
           categoryId: meta.categoryId || old.snippet?.categoryId,
-          privacyStatus: 'unlisted',
+          privacyStatus: uploadPrivacy,
           selfDeclaredMadeForKids: meta.selfDeclaredMadeForKids
             ?? (old.status?.madeForKids !== undefined ? old.status.madeForKids : false),
         };
@@ -68,7 +68,7 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
   let lastErr;
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
-      return await uploadVideo(youtube, newVideoPath, meta, 'unlisted');
+      return await uploadVideo(youtube, newVideoPath, meta, uploadPrivacy);
     } catch (err) {
       lastErr = err;
       if (attempt < retries) {
@@ -142,20 +142,25 @@ export async function removeOldItem(youtube, oldPlaylistItemId) {
 }
 
 /**
- * Step 5 — Finalize: unlist the old video (never delete), then publish the
- * new one. Ordered so any earlier failure leaves the old video untouched.
+ * Step 5 — Finalize swap privacy on old and new videos.
  *
  * @param {import('googleapis').youtube_v3.Youtube} youtube
  * @param {string} oldVideoId
  * @param {string} newVideoId
+ * @param {object} [options]
+ * @param {'private' | 'unlisted' | 'public'} [options.newPrivacyStatus='public']
+ * @param {'private' | 'unlisted' | 'public'} [options.oldPrivacyStatus='unlisted']
  */
-export async function finalizeSwap(youtube, oldVideoId, newVideoId) {
+export async function finalizeSwap(youtube, oldVideoId, newVideoId, options = {}) {
+  const newPrivacyStatus = options.newPrivacyStatus || 'public';
+  const oldPrivacyStatus = options.oldPrivacyStatus || 'unlisted';
+
   await youtube.videos.update({
     part: ['status'],
-    requestBody: { id: oldVideoId, status: { privacyStatus: 'unlisted' } },
+    requestBody: { id: oldVideoId, status: { privacyStatus: oldPrivacyStatus } },
   });
   await youtube.videos.update({
     part: ['status'],
-    requestBody: { id: newVideoId, status: { privacyStatus: 'public' } },
+    requestBody: { id: newVideoId, status: { privacyStatus: newPrivacyStatus } },
   });
 }

package/src/swap/swapSong.js

@@ -33,6 +33,7 @@ export const QUOTA_PER_SWAP = 150 + 1; // ~150 shared units + 1 upload-bucket un
  * @param {string} [params.stateDir] - Where the swap state file lives (default: cwd)
  * @param {string} [params.stateFile] - Custom state filename
  * @param {boolean} [params.fresh=false] - Reset any existing record for songKey
+ * @param {'preserve' | 'private' | 'public'} [params.privacyMode='public'] - Final privacy for new video; preserve reads old video status
  * @param {(event: { type: string, [key: string]: any }) => void} [params.onEvent]
  * @returns {Promise<{ record: any, dryRunPlan?: string[] }>}
  */
@@ -47,6 +48,7 @@ export async function swapSong(params) {
     stateDir,
     stateFile,
     fresh = false,
+    privacyMode = 'public',
     onEvent = () => {},
   } = params;
 
@@ -84,13 +86,46 @@ export async function swapSong(params) {
   }
 
   try {
+    let resolvedNewPrivacy = 'public';
+    let resolvedOldPrivacy = 'unlisted';
+    let uploadPrivacy = 'unlisted';
+
+    if (privacyMode === 'private') {
+      resolvedNewPrivacy = 'private';
+      resolvedOldPrivacy = 'unlisted';
+      uploadPrivacy = 'private';
+    } else if (privacyMode === 'preserve') {
+      try {
+        const res = await youtube.videos.list({
+          part: ['status'],
+          id: [oldVideoId],
+        });
+        const oldStatus = res.data.items?.[0]?.status?.privacyStatus;
+        if (oldStatus === 'private' || oldStatus === 'unlisted' || oldStatus === 'public') {
+          resolvedNewPrivacy = oldStatus;
+          uploadPrivacy = oldStatus;
+        } else {
+          resolvedNewPrivacy = 'private';
+          uploadPrivacy = 'private';
+        }
+      } catch {
+        resolvedNewPrivacy = 'private';
+        uploadPrivacy = 'private';
+      }
+      resolvedOldPrivacy = 'unlisted';
+    }
+
     // 1. UPLOAD
     await step('uploaded', async () => {
       const alreadyUploaded = store.getRecord(songKey).newVideoId;
       if (alreadyUploaded) {
         return { videoId: alreadyUploaded };
       }
-      const up = await uploadNewVideo(youtube, newVideoPath, { oldVideoId, meta });
+      const up = await uploadNewVideo(youtube, newVideoPath, {
+        oldVideoId,
+        meta,
+        uploadPrivacy,
+      });
       onEvent({ type: 'swap_uploaded', songKey, newVideoId: up.videoId, url: up.url });
       return up;
     }, r => ({ newVideoId: r.videoId }));
@@ -128,7 +163,10 @@ export async function swapSong(params) {
 
     // 5. FINALIZE
     await step('finalized', async () => {
-      await finalizeSwap(youtube, oldVideoId, newVideoId);
+      await finalizeSwap(youtube, oldVideoId, newVideoId, {
+        newPrivacyStatus: resolvedNewPrivacy,
+        oldPrivacyStatus: resolvedOldPrivacy,
+      });
     });
 
     onEvent({ type: 'swap_complete', songKey, oldVideoId, newVideoId, playlistId });