@mux/ai 0.45.0 → 0.47.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // package.json
-var version = "0.45.0";
+var version = "0.47.0";
 
 // src/lib/language-codes.ts
 var ISO639_1_TO_3 = {
@@ -1055,7 +1055,7 @@ function resolveDirectMuxCredentials(record) {
 function createWorkflowMuxClient(options) {
   return {
     async createClient() {
-      const { default: MuxClient } = await import("@mux/mux-node");
+      const { default: MuxClient } = await import("@mux/ts");
       return new MuxClient({
         tokenId: options.tokenId,
         tokenSecret: options.tokenSecret,
@@ -1195,17 +1195,24 @@ function findNameCollisionTextTracks(asset, target) {
   }
   return listTracks(asset, targetType(target)).filter((track) => normalizeTrackName(track.name) === targetName);
 }
+function countTracks(tracks, label, singularVerb, pluralVerb) {
+  const kind = label.toLowerCase();
+  if (tracks.length === 1) {
+    return `${kind === "audio" ? "An" : "A"} ${kind} track ${singularVerb}`;
+  }
+  return `${tracks.length} ${kind} tracks ${pluralVerb}`;
+}
+function itOrThem(tracks) {
+  return tracks.length === 1 ? "it" : "them";
+}
 function describeTracks(tracks) {
   return tracks.map((track) => `${track.name ?? "(unnamed)"} [${track.language_code ?? "?"}, ${track.type === "audio" ? track.primary ? "primary audio" : "audio" : track.text_source ?? "unknown source"}, ${track.status ?? "ready"}]`).join("; ");
 }
-function planTextTrackReplacement(asset, target, policy, options = {}) {
+function planTextTrackReplacement(asset, target, policy) {
   const label = targetType(target) === "audio" ? "Audio" : "Text";
-  const keep = new Set(options.keepTrackIds ?? []);
   const conflicts = /* @__PURE__ */ new Map();
   for (const track of [...findSameLanguageTextTracks(asset, target), ...findNameCollisionTextTracks(asset, target)]) {
-    if (!keep.has(track.id)) {
-      conflicts.set(track.id, track);
-    }
+    conflicts.set(track.id, track);
   }
   const conflicting = [...conflicts.values()];
   if (conflicting.length === 0) {
@@ -1214,7 +1221,7 @@ function planTextTrackReplacement(asset, target, policy, options = {}) {
   if (policy === "fail") {
     return {
       kind: "blocked",
-      reason: `${label} track(s) already exist for language '${target.languageCode}' or name '${target.name}': ${describeTracks(conflicting)}. Set replaceExistingTracks to replace them.`,
+      reason: `${countTracks(conflicting, label, "already exists", "already exist")} for language '${target.languageCode}' or name '${target.name}': ${describeTracks(conflicting)}. Set replaceExistingTracks to replace ${itOrThem(conflicting)}.`,
       tracks: conflicting.map(summarizeTextTrack)
     };
   }
@@ -1231,13 +1238,26 @@ function planTextTrackReplacement(asset, target, policy, options = {}) {
     if (notGenerated.length > 0) {
       return {
         kind: "blocked",
-        reason: `${label} track(s) that are not Mux-generated exist for language '${target.languageCode}' or name '${target.name}': ${describeTracks(notGenerated)}. Use replaceExistingTracks: "replace_all" to replace them.`,
+        reason: `${countTracks(notGenerated, label, "that is not Mux-generated exists", "that are not Mux-generated exist")} for language '${target.languageCode}' or name '${target.name}': ${describeTracks(notGenerated)}. Use replaceExistingTracks: "replace_all" to replace ${itOrThem(notGenerated)}.`,
         tracks: notGenerated.map(summarizeTextTrack)
       };
     }
   }
   return { kind: "replace", toDelete: conflicting.map(summarizeTextTrack) };
 }
+function planSourceTrackReplacement(asset, sourceTrackId, target, policy) {
+  const colliding = findNameCollisionTextTracks(asset, target);
+  const blocking = policy === "fail" ? colliding : colliding.filter((track) => track.id !== sourceTrackId);
+  if (blocking.length > 0) {
+    return {
+      kind: "blocked",
+      reason: `${countTracks(blocking, "Text", "already has", "already have")} the name '${target.name}': ${describeTracks(blocking)}. Choose a different trackName.`,
+      tracks: blocking.map(summarizeTextTrack)
+    };
+  }
+  const source = policy === "replace" ? listTracks(asset, targetType(target)).find((track) => track.id === sourceTrackId) : void 0;
+  return source ? { kind: "replace", toDelete: [summarizeTextTrack(source)] } : { kind: "clear" };
+}
 function isDuplicateTrackNameError(error) {
   if (typeof error !== "object" || error === null) {
     return false;
@@ -1293,6 +1313,14 @@ async function createTextTrackOnMux(assetId, languageCode, trackName, presignedU
 }
 async function replaceAndCreateTrack(input) {
   "use step";
+  return writeTrack(input, (asset) => planTextTrackReplacement(asset, input.target, input.policy));
+}
+async function replaceSourceTrack(input) {
+  "use step";
+  const target = { ...input.target, type: "text" };
+  return writeTrack({ ...input, target }, (asset) => planSourceTrackReplacement(asset, input.sourceTrackId, target, input.policy));
+}
+async function writeTrack(input, plan) {
   const muxClient = await resolveMuxClient(input.credentials);
   const mux = await muxClient.createClient();
   const type = targetType(input.target);
@@ -1312,12 +1340,12 @@ async function replaceAndCreateTrack(input) {
       }
       return failed(error);
     }
-    const plan = planTextTrackReplacement(asset, input.target, input.policy, { keepTrackIds: input.keepTrackIds });
-    if (plan.kind === "blocked") {
-      return { ...plan, deleted };
+    const planned = plan(asset);
+    if (planned.kind === "blocked") {
+      return { ...planned, deleted };
     }
-    if (plan.kind === "replace") {
-      for (const track of plan.toDelete) {
+    if (planned.kind === "replace") {
+      for (const track of planned.toDelete) {
         try {
           await mux.video.assets.deleteTrack(input.assetId, track.id);
           deleted.push(track);
@@ -2182,25 +2210,22 @@ async function getHeatmapForPlaybackId(playbackId, options = {}) {
   "use step";
   return fetchHeatmap("playback-ids", playbackId, options);
 }
-function transformHeatmapResponse(response) {
-  return {
-    assetId: response.data.asset_id,
-    videoId: response.data.video_id,
-    playbackId: response.data.playback_id,
-    heatmap: response.data.heatmap,
-    timeframe: response.timeframe
-  };
-}
 async function fetchHeatmap(identifierType, id, options) {
   "use step";
   const { timeframe = "7:days", credentials } = options;
   const muxClient = await getMuxClientFromEnv(credentials);
   const mux = await muxClient.createClient();
-  const queryParams = new URLSearchParams();
-  queryParams.append("timeframe[]", timeframe);
-  const path = `/data/v1/engagement/${identifierType}/${id}/heatmap?${queryParams.toString()}`;
-  const response = await mux.get(path);
-  return transformHeatmapResponse(response);
+  const query = { timeframe: [timeframe] };
+  const resource = identifierType === "playback-ids" ? mux.data.engagement.playbackIds : mux.data.engagement[identifierType];
+  const response = await resource.heatmap(id, query);
+  const { data } = response;
+  return {
+    assetId: data.asset_id ?? (identifierType === "assets" ? id : void 0),
+    videoId: data.video_id ?? (identifierType === "videos" ? id : void 0),
+    playbackId: data.playback_id ?? (identifierType === "playback-ids" ? id : void 0),
+    heatmap: data.heatmap,
+    timeframe: response.timeframe
+  };
 }
 
 // src/primitives/hotspots.ts
@@ -2219,37 +2244,34 @@ async function getHotspotsForPlaybackId(playbackId, options = {}) {
   const response = await fetchHotspots("playback-ids", playbackId, options);
   return response.hotspots;
 }
-function transformHotspotResponse(response) {
-  return {
-    assetId: response.data.asset_id,
-    videoId: response.data.video_id,
-    playbackId: response.data.playback_id,
-    hotspots: response.data.hotspots.map((h) => ({
-      startMs: h.start_ms,
-      endMs: h.end_ms,
-      score: h.score
-    }))
-  };
-}
 async function fetchHotspots(identifierType, id, options) {
   "use step";
   const {
     limit = 5,
     orderDirection = "desc",
-    orderBy = "score",
     timeframe = "7:days",
     credentials
   } = options;
   const muxClient = await getMuxClientFromEnv(credentials);
   const mux = await muxClient.createClient();
-  const queryParams = new URLSearchParams();
-  queryParams.append("limit", String(limit));
-  queryParams.append("order_direction", orderDirection);
-  queryParams.append("order_by", orderBy);
-  queryParams.append("timeframe[]", timeframe);
-  const path = `/data/v1/engagement/${identifierType}/${id}/hotspots?${queryParams.toString()}`;
-  const response = await mux.get(path);
-  return transformHotspotResponse(response);
+  const query = {
+    limit,
+    order_direction: orderDirection,
+    timeframe: [timeframe]
+  };
+  const resource = identifierType === "playback-ids" ? mux.data.engagement.playbackIds : mux.data.engagement[identifierType];
+  const response = await resource.hotspots(id, query);
+  const { data } = response;
+  return {
+    assetId: data.asset_id ?? (identifierType === "assets" ? id : void 0),
+    videoId: data.video_id ?? (identifierType === "videos" ? id : void 0),
+    playbackId: data.playback_id ?? (identifierType === "playback-ids" ? id : void 0),
+    hotspots: data.hotspots.map((h) => ({
+      startMs: h.start_ms,
+      endMs: h.end_ms,
+      score: h.score
+    }))
+  };
 }
 
 // src/primitives/shots.ts
@@ -2257,9 +2279,6 @@ var DEFAULT_POLL_INTERVAL_MS = 2e3;
 var MIN_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_MAX_ATTEMPTS = 60;
 var SHOTS_ALREADY_REQUESTED_MESSAGE = "shots generation has already been requested";
-function getShotsPath(assetId) {
-  return `/video/v1/assets/${assetId}/shots`;
-}
 function mapManifestShots(shots) {
   let usedDeprecatedField = false;
   const mapped = shots.map((shot, index) => {
@@ -2299,29 +2318,35 @@ async function fetchShotsFromManifest(shotsManifestUrl) {
   }
   return mapManifestShots(manifest.shots);
 }
-async function transformShotsResponse(response) {
-  switch (response.data.status) {
+async function transformShotsResponse(data) {
+  switch (data.status) {
     case "pending":
       return {
         status: "pending",
-        createdAt: response.data.created_at
+        createdAt: data.created_at
       };
-    case "errored":
+    case "errored": {
+      const details = data.errors ?? data.error;
       return {
         status: "errored",
-        createdAt: response.data.created_at,
-        error: response.data.error
+        createdAt: data.created_at,
+        error: {
+          type: details?.type ?? "unknown",
+          messages: details?.messages ?? []
+        }
       };
+    }
     case "completed":
+      if (!data.shots_manifest_url) {
+        throw new Error("Completed shots response is missing shots_manifest_url");
+      }
       return {
         status: "completed",
-        createdAt: response.data.created_at,
-        shots: await fetchShotsFromManifest(response.data.shots_manifest_url)
+        createdAt: data.created_at,
+        shots: await fetchShotsFromManifest(data.shots_manifest_url)
       };
-    default: {
-      const exhaustiveCheck = response.data;
-      throw new Error(`Unsupported shots response: ${JSON.stringify(exhaustiveCheck)}`);
-    }
+    default:
+      throw new Error(`Unsupported shots status '${data.status}'`);
   }
 }
 function sleep(ms) {
@@ -2329,7 +2354,8 @@ function sleep(ms) {
 }
 function isShotsAlreadyRequestedError(error) {
   const statusCode = error?.status ?? error?.statusCode;
-  const messages = error?.error?.messages;
+  const body = error?.error;
+  const messages = body?.error?.messages ?? body?.messages;
   const lowerCaseMessages = messages?.map((message) => message.toLowerCase()) ?? [];
   const errorMessage = error instanceof Error ? error.message.toLowerCase() : "";
   return statusCode === 400 && (lowerCaseMessages.some((message) => message.includes(SHOTS_ALREADY_REQUESTED_MESSAGE)) || errorMessage.includes(SHOTS_ALREADY_REQUESTED_MESSAGE));
@@ -2339,11 +2365,8 @@ async function requestShotsForAsset(assetId, options = {}) {
   const { credentials } = options;
   const muxClient = await getMuxClientFromEnv(credentials);
   const mux = await muxClient.createClient();
-  const response = await mux.post(
-    getShotsPath(assetId),
-    { body: {} }
-  );
-  const result = await transformShotsResponse(response);
+  const data = await mux.video.assets.generateShots(assetId, {});
+  const result = await transformShotsResponse(data);
   if (result.status !== "pending") {
     throw new Error(
       `Expected pending status after requesting shots for asset '${assetId}', received '${result.status}'`
@@ -2356,10 +2379,8 @@ async function getShotsForAsset(assetId, options = {}) {
   const { credentials } = options;
   const muxClient = await getMuxClientFromEnv(credentials);
   const mux = await muxClient.createClient();
-  const response = await mux.get(
-    getShotsPath(assetId)
-  );
-  return await transformShotsResponse(response);
+  const data = await mux.video.assets.retrieveShots(assetId);
+  return await transformShotsResponse(data);
 }
 async function waitForShotsForAsset(assetId, options = {}) {
   "use step";
@@ -2402,12 +2423,8 @@ async function waitForShotsForAsset(assetId, options = {}) {
 
 // src/lib/url-signing.ts
 async function createSigningClient(context) {
-  const { default: MuxClient } = await import("@mux/mux-node");
+  const { default: MuxClient } = await import("@mux/ts");
   return new MuxClient({
-    // These are not needed for signing, but the SDK requires them
-    // Using empty strings as we only need the jwt functionality
-    tokenId: env_default.MUX_TOKEN_ID || "",
-    tokenSecret: env_default.MUX_TOKEN_SECRET || "",
     jwtSigningKey: context.keyId,
     jwtPrivateKey: context.keySecret
   });
@@ -5507,7 +5524,13 @@ async function editCaptionsInternal(assetId, trackId, options, collectedUsage) {
       { type: "validation_error" }
     );
   }
-  const replaceExistingTracks = replaceExistingTracksOption ?? "replace_all";
+  if (replaceExistingTracksOption !== void 0 && replaceExistingTracksOption !== "replace" && replaceExistingTracksOption !== "fail") {
+    throw new MuxAiError(
+      `replaceExistingTracks must be "replace" or "fail" for editCaptions (received "${String(replaceExistingTracksOption)}").`,
+      { type: "validation_error" }
+    );
+  }
+  const replaceExistingTracks = replaceExistingTracksOption ?? "replace";
   if (!legacyTrackNaming && replaceExistingTracks === "fail" && !providedTrackName) {
     throw new MuxAiError(
       `trackName is required when replaceExistingTracks is "fail": the edited track cannot reuse the source track's name while the source is kept.`,
@@ -5563,15 +5586,14 @@ async function editCaptionsInternal(assetId, trackId, options, collectedUsage) {
     languageCode: sourceLanguageCode,
     name: providedTrackName ?? sourceName
   };
-  const keepTrackIds = replaceExistingTracks === "fail" ? [trackId] : [];
   if (replaceExistingTracks === "fail" && normalizeTrackName(outputTrack.name) === normalizeTrackName(sourceName)) {
     throw new MuxAiError(
-      `trackName "${outputTrack.name}" matches the source track's name. Mux track names must be unique; choose a different trackName or use replaceExistingTracks: "replace_all" to replace the source.`,
+      `trackName "${outputTrack.name}" matches the source track's name. Mux track names must be unique; choose a different trackName or use replaceExistingTracks: "replace" to replace the source.`,
       { type: "validation_error" }
     );
   }
   if (uploadToMux && !legacyTrackNaming) {
-    const plan = planTextTrackReplacement(assetData, outputTrack, replaceExistingTracks, { keepTrackIds });
+    const plan = planSourceTrackReplacement(assetData, trackId, outputTrack, replaceExistingTracks);
     if (plan.kind === "blocked") {
       throw new MuxAiError(plan.reason, { type: "validation_error" });
     }
@@ -5693,14 +5715,14 @@ async function editCaptionsInternal(assetId, trackId, options, collectedUsage) {
     } else if (uploadToMux) {
       let outcome;
       try {
-        outcome = await replaceAndCreateTextTrack({
+        outcome = await replaceSourceTrack({
           assetId,
+          sourceTrackId: trackId,
           target: outputTrack,
           policy: replaceExistingTracks,
           presignedUrl,
           closedCaptions: sourceTrack.closed_captions,
           passthrough: trackPassthrough,
-          keepTrackIds,
           credentials
         });
       } catch (error) {
@@ -9900,10 +9922,12 @@ export {
   isValidISO639_3,
   normalizeTrackLanguageCode,
   normalizeTrackName,
+  planSourceTrackReplacement,
   planTextTrackReplacement,
   primitives_exports as primitives,
   replaceAndCreateTextTrack,
   replaceAndCreateTrack,
+  replaceSourceTrack,
   setWorkflowCredentialsProvider,
   summarizeTextTrack,
   toISO639_1,