@mux/ai 0.10.0 → 0.11.0

package/dist/primitives/index.d.ts

@@ -1,3 +1,3 @@
-export { D as DEFAULT_STORYBOARD_WIDTH, H as HeatmapOptions, a as HeatmapResponse, b as Hotspot, c as HotspotOptions, d as HotspotResponse, T as ThumbnailOptions, e as TranscriptFetchOptions, f as TranscriptResult, V as VTTCue, g as VTTCueBudgetChunkingOptions, h as VTTDurationChunk, j as VTTDurationChunkingOptions, k as buildTranscriptUrl, l as buildVttFromCueBlocks, m as buildVttFromTranslatedCueBlocks, n as chunkByTokens, o as chunkText, p as chunkVTTCues, q as chunkVTTCuesByBudget, r as chunkVTTCuesByDuration, s as concatenateVttSegments, t as estimateTokenCount, u as extractTextFromVTT, v as extractTimestampedTranscript, w as fetchTranscriptForAsset, x as findCaptionTrack, y as getHeatmapForAsset, z as getHeatmapForPlaybackId, A as getHeatmapForVideo, B as getHotspotsForAsset, C as getHotspotsForPlaybackId, E as getHotspotsForVideo, F as getReadyTextTracks, G as getStoryboardUrl, I as getThumbnailUrls, J as parseVTTCues, K as replaceCueText, L as secondsToTimestamp, M as splitVttPreambleAndCueBlocks, N as vttTimestampToSeconds } from '../index-C8-E3VR9.js';
+export { C as CompletedShotsResult, D as DEFAULT_STORYBOARD_WIDTH, E as ErroredShotsResult, H as HeatmapOptions, a as HeatmapResponse, b as Hotspot, c as HotspotOptions, d as HotspotResponse, P as PendingShotsResult, S as Shot, e as ShotRequestOptions, f as ShotsResult, T as ThumbnailOptions, g as TranscriptFetchOptions, h as TranscriptResult, V as VTTCue, j as VTTCueBudgetChunkingOptions, k as VTTDurationChunk, l as VTTDurationChunkingOptions, W as WaitForShotsOptions, m as buildTranscriptUrl, n as buildVttFromCueBlocks, o as buildVttFromTranslatedCueBlocks, p as chunkByTokens, q as chunkText, r as chunkVTTCues, s as chunkVTTCuesByBudget, t as chunkVTTCuesByDuration, u as concatenateVttSegments, v as estimateTokenCount, w as extractTextFromVTT, x as extractTimestampedTranscript, y as fetchTranscriptForAsset, z as findCaptionTrack, A as getHeatmapForAsset, B as getHeatmapForPlaybackId, F as getHeatmapForVideo, G as getHotspotsForAsset, I as getHotspotsForPlaybackId, J as getHotspotsForVideo, K as getReadyTextTracks, L as getShotsForAsset, M as getStoryboardUrl, N as getThumbnailUrls, O as parseVTTCues, Q as replaceCueText, R as requestShotsForAsset, U as secondsToTimestamp, X as splitVttPreambleAndCueBlocks, Y as vttTimestampToSeconds, Z as waitForShotsForAsset } from '../index-DLhfJsOd.js';
 import '../types-BRbaGW3t.js';
 import '@mux/mux-node';

package/dist/primitives/index.js

@@ -592,6 +592,142 @@ async function fetchHotspots(identifierType, id, options) {
   return transformHotspotResponse(response);
 }
 
+// src/primitives/shots.ts
+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) {
+  return shots.map((shot, index) => {
+    const { startTime, imageUrl } = shot;
+    if (typeof startTime !== "number" || !Number.isFinite(startTime)) {
+      throw new TypeError(`Invalid shot startTime in shots manifest at index ${index}`);
+    }
+    if (typeof imageUrl !== "string" || imageUrl.length === 0) {
+      throw new TypeError(`Invalid shot imageUrl in shots manifest at index ${index}`);
+    }
+    return {
+      startTime,
+      imageUrl
+    };
+  });
+}
+async function fetchShotsFromManifest(shotsManifestUrl) {
+  const response = await fetch(shotsManifestUrl);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch shots manifest: ${response.status} ${response.statusText}`
+    );
+  }
+  const manifest = await response.json();
+  if (!Array.isArray(manifest.shots)) {
+    throw new TypeError("Invalid shots manifest response: missing shots array");
+  }
+  return mapManifestShots(manifest.shots);
+}
+async function transformShotsResponse(response) {
+  switch (response.data.status) {
+    case "pending":
+      return {
+        status: "pending",
+        createdAt: response.data.created_at
+      };
+    case "errored":
+      return {
+        status: "errored",
+        createdAt: response.data.created_at,
+        error: response.data.error
+      };
+    case "completed":
+      return {
+        status: "completed",
+        createdAt: response.data.created_at,
+        shots: await fetchShotsFromManifest(response.data.shots_manifest_url)
+      };
+    default: {
+      const exhaustiveCheck = response.data;
+      throw new Error(`Unsupported shots response: ${JSON.stringify(exhaustiveCheck)}`);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isShotsAlreadyRequestedError(error) {
+  const statusCode = error?.status ?? error?.statusCode;
+  const messages = error?.error?.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));
+}
+async function requestShotsForAsset(assetId, options = {}) {
+  "use step";
+  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);
+  if (result.status !== "pending") {
+    throw new Error(
+      `Expected pending status after requesting shots for asset '${assetId}', received '${result.status}'`
+    );
+  }
+  return result;
+}
+async function getShotsForAsset(assetId, options = {}) {
+  "use step";
+  const { credentials } = options;
+  const muxClient = await getMuxClientFromEnv(credentials);
+  const mux = await muxClient.createClient();
+  const response = await mux.get(
+    getShotsPath(assetId)
+  );
+  return await transformShotsResponse(response);
+}
+async function waitForShotsForAsset(assetId, options = {}) {
+  "use step";
+  const {
+    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    createIfMissing = true,
+    credentials
+  } = options;
+  if (createIfMissing) {
+    try {
+      await requestShotsForAsset(assetId, { credentials });
+    } catch (error) {
+      if (!isShotsAlreadyRequestedError(error)) {
+        throw error;
+      }
+    }
+  }
+  const normalizedMaxAttempts = Math.max(1, maxAttempts);
+  const normalizedPollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, pollIntervalMs);
+  let lastStatus;
+  for (let attempt = 0; attempt < normalizedMaxAttempts; attempt++) {
+    const result = await getShotsForAsset(assetId, { credentials });
+    lastStatus = result.status;
+    if (result.status === "completed") {
+      return result;
+    }
+    if (result.status === "errored") {
+      throw new Error(`Shots generation errored for asset '${assetId}'`);
+    }
+    if (attempt < normalizedMaxAttempts - 1) {
+      await sleep(normalizedPollIntervalMs);
+    }
+  }
+  throw new Error(
+    `Timed out waiting for shots for asset '${assetId}' after ${normalizedMaxAttempts} attempts. Last status: ${lastStatus ?? "unknown"}`
+  );
+}
+
 // src/lib/mux-image-url.ts
 var DEFAULT_MUX_IMAGE_ORIGIN = "https://image.mux.com";
 function normalizeMuxImageOrigin(value) {
@@ -1314,12 +1450,15 @@ export {
   getHotspotsForPlaybackId,
   getHotspotsForVideo,
   getReadyTextTracks,
+  getShotsForAsset,
   getStoryboardUrl,
   getThumbnailUrls,
   parseVTTCues,
   replaceCueText,
+  requestShotsForAsset,
   secondsToTimestamp,
   splitVttPreambleAndCueBlocks,
-  vttTimestampToSeconds
+  vttTimestampToSeconds,
+  waitForShotsForAsset
 };
 //# sourceMappingURL=index.js.map