@epic-web/workshop-utils 6.73.0 → 6.74.1

package/dist/epic-api.server.d.ts

@@ -1,6 +1,42 @@
 import { z } from 'zod';
 import { type Timings } from "./timing.server.js";
+declare const EpicVideoMetadataSchema: z.ZodObject<{
+    playbackId: z.ZodString;
+    assetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    downloads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        quality: z.ZodString;
+        url: z.ZodString;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        bitrate: z.ZodOptional<z.ZodNumber>;
+        filesize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
 export type EpicVideoInfos = Record<string, Awaited<ReturnType<typeof getEpicVideoInfo>>>;
+export type EpicVideoMetadata = z.infer<typeof EpicVideoMetadataSchema>;
+export declare function normalizeVideoApiHost(host: string): string;
+export declare function getEpicVideoMetadata({ playbackId, host, accessToken, request, timings, }: {
+    playbackId: string;
+    host: string;
+    accessToken?: string;
+    request?: Request;
+    timings?: Timings;
+}): Promise<{
+    playbackId: string;
+    assetId?: string | null | undefined;
+    status?: string | null | undefined;
+    duration?: number | null | undefined;
+    downloads?: {
+        quality: string;
+        url: string;
+        width?: number | undefined;
+        height?: number | undefined;
+        bitrate?: number | undefined;
+        filesize?: number | undefined;
+    }[] | null | undefined;
+} | null>;
 export declare function getEpicVideoInfos(epicWebUrls?: Array<string> | null, { request, timings }?: {
     request?: Request;
     timings?: Timings;
@@ -13,6 +49,11 @@ declare function getEpicVideoInfo({ epicVideoEmbed, accessToken, request, timing
 }): Promise<{
     transcript: string;
     muxPlaybackId: string;
+    downloadsAvailable: boolean;
+    downloadSizes: {
+        quality: string;
+        size: number | null;
+    }[];
     status: "success";
     statusCode: number;
     statusText: string;

package/dist/epic-api.server.js

@@ -43,6 +43,25 @@ const EpicVideoInfoSchema = z
     }
     return data;
 });
+const EpicVideoDownloadSchema = z.object({
+    quality: z.string(),
+    url: z.string(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+    bitrate: z.number().optional(),
+    filesize: z.number().optional(),
+});
+const EpicVideoDownloadSizeSchema = z.object({
+    quality: z.string(),
+    size: z.number().nullable(),
+});
+const EpicVideoMetadataSchema = z.object({
+    playbackId: z.string(),
+    assetId: z.string().nullable().optional(),
+    status: z.string().nullable().optional(),
+    duration: z.number().nullable().optional(),
+    downloads: z.array(EpicVideoDownloadSchema).nullable().optional(),
+});
 function hmsToSeconds(str) {
     const p = str.split(':');
     let s = 0;
@@ -65,6 +84,8 @@ const CachedEpicVideoInfoSchema = z
     muxPlaybackId: z.string(),
     duration: z.number().nullable().optional(),
     durationEstimate: z.number().nullable().optional(),
+    downloadsAvailable: z.boolean().optional().default(false),
+    downloadSizes: z.array(EpicVideoDownloadSizeSchema).optional().default([]),
     status: z.literal('success'),
     statusCode: z.number(),
     statusText: z.string(),
@@ -85,7 +106,62 @@ const CachedEpicVideoInfoSchema = z
 }))
     .or(z.null());
 const videoInfoLog = log.logger('video-info');
+const videoMetadataLog = log.logger('video-metadata');
 const EPIC_VIDEO_INFO_CONCURRENCY = 6;
+export function normalizeVideoApiHost(host) {
+    if (host === 'epicweb.dev')
+        return 'www.epicweb.dev';
+    if (host === 'epicreact.dev')
+        return 'www.epicreact.dev';
+    if (host === 'epicai.pro')
+        return 'www.epicai.pro';
+    return host;
+}
+export async function getEpicVideoMetadata({ playbackId, host, accessToken, request, timings, }) {
+    if (getEnv().EPICSHOP_DEPLOYED)
+        return null;
+    const normalizedHost = normalizeVideoApiHost(host);
+    const key = `epic-video-metadata:${normalizedHost}:${playbackId}`;
+    return cachified({
+        key,
+        request,
+        cache: epicApiCache,
+        timings,
+        ttl: 1000 * 60 * 60,
+        swr: 1000 * 60 * 60 * 24 * 365 * 10,
+        offlineFallbackValue: null,
+        checkValue: EpicVideoMetadataSchema.nullable(),
+        async getFreshValue(context) {
+            const apiUrl = `https://${normalizedHost}/api/video/${encodeURIComponent(playbackId)}`;
+            videoMetadataLog(`making video metadata request to: ${apiUrl}`);
+            const response = await fetch(apiUrl, accessToken
+                ? { headers: { authorization: `Bearer ${accessToken}` } }
+                : undefined).catch((e) => new Response(getErrorMessage(e), { status: 500 }));
+            videoMetadataLog(`video metadata response: ${response.status} ${response.statusText}`);
+            if (!response.ok) {
+                context.metadata.ttl = 1000 * 2;
+                context.metadata.swr = 0;
+                return null;
+            }
+            const rawInfo = await response.json();
+            const parsedInfo = EpicVideoMetadataSchema.safeParse(rawInfo);
+            if (parsedInfo.success) {
+                return parsedInfo.data;
+            }
+            context.metadata.ttl = 1000 * 2;
+            context.metadata.swr = 0;
+            videoMetadataLog.error(`video metadata parsing failed for ${playbackId}`, {
+                host: normalizedHost,
+                rawInfo,
+                parseError: parsedInfo.error,
+            });
+            return null;
+        },
+    }).catch((e) => {
+        videoMetadataLog.error(`failed to fetch video metadata for ${playbackId}:`, e);
+        return null;
+    });
+}
 export async function getEpicVideoInfos(epicWebUrls, { request, timings } = {}) {
     if (!epicWebUrls) {
         videoInfoLog.warn('no epic web URLs provided, returning empty object');
@@ -158,12 +234,33 @@ async function getEpicVideoInfo({ epicVideoEmbed, accessToken, request, timings,
                 }
                 const infoResult = EpicVideoInfoSchema.safeParse(rawInfo);
                 if (infoResult.success) {
+                    const metadata = await getEpicVideoMetadata({
+                        playbackId: infoResult.data.muxPlaybackId,
+                        host: epicUrl.host,
+                        accessToken,
+                        request,
+                        timings,
+                    });
+                    const duration = metadata?.duration ?? infoResult.data.duration;
+                    const downloadSizes = metadata?.downloads
+                        ?.filter((download) => Boolean(download.url))
+                        .map((download) => ({
+                        quality: download.quality,
+                        size: typeof download.filesize === 'number' &&
+                            Number.isFinite(download.filesize)
+                            ? download.filesize
+                            : null,
+                    })) ?? [];
+                    const downloadsAvailable = downloadSizes.length > 0;
                     videoInfoLog(`successfully parsed video info for ${epicVideoEmbed}`);
                     return {
                         status: 'success',
                         statusCode: status,
                         statusText,
                         ...infoResult.data,
+                        duration,
+                        downloadsAvailable,
+                        downloadSizes,
                     };
                 }
                 else {

package/dist/offline-video-utils.d.ts

@@ -0,0 +1,7 @@
+export declare const offlineVideoDownloadResolutions: readonly ["best", "high", "medium", "low"];
+export type OfflineVideoDownloadResolution = (typeof offlineVideoDownloadResolutions)[number];
+export declare const videoDownloadQualityOrder: Record<OfflineVideoDownloadResolution, Array<string>>;
+export declare function getPreferredDownloadSize(downloadSizes: Array<{
+    quality: string;
+    size: number | null;
+}>, resolution: OfflineVideoDownloadResolution): number | null;

package/dist/offline-video-utils.js

@@ -0,0 +1,27 @@
+export const offlineVideoDownloadResolutions = [
+    'best',
+    'high',
+    'medium',
+    'low',
+];
+export const videoDownloadQualityOrder = {
+    best: ['source', 'highest', 'high', 'medium', 'low'],
+    high: ['high', 'medium', 'low', 'highest', 'source'],
+    medium: ['medium', 'low', 'high', 'highest', 'source'],
+    low: ['low', 'medium', 'high', 'highest', 'source'],
+};
+export function getPreferredDownloadSize(downloadSizes, resolution) {
+    if (downloadSizes.length === 0)
+        return null;
+    const sizeByQuality = new Map(downloadSizes.map((download) => [
+        download.quality.toLowerCase(),
+        download.size,
+    ]));
+    const order = videoDownloadQualityOrder[resolution] ?? videoDownloadQualityOrder.best;
+    for (const quality of order) {
+        const size = sizeByQuality.get(quality);
+        if (typeof size === 'number' && Number.isFinite(size) && size > 0)
+            return size;
+    }
+    return (downloadSizes.find((download) => typeof download.size === 'number' && Number.isFinite(download.size))?.size ?? null);
+}

package/dist/offline-videos.server.d.ts

@@ -26,6 +26,8 @@ export type OfflineVideoSummary = {
     totalVideos: number;
     downloadedVideos: number;
     unavailableVideos: number;
+    notDownloadableVideos: number;
+    remainingDownloadBytes: number;
     totalBytes: number;
     downloadState: OfflineVideoDownloadState;
 };
@@ -34,6 +36,7 @@ export type OfflineVideoStartResult = {
     available: number;
     queued: number;
     unavailable: number;
+    notDownloadable: number;
     alreadyDownloaded: number;
 };
 export type OfflineVideoAdminEntry = {

package/dist/offline-videos.server.js

@@ -8,16 +8,11 @@ import { getApps, getExercises, getWorkshopFinished, getWorkshopInstructions, }
 import { getWorkshopConfig } from "./config.server.js";
 import { resolvePrimaryDir } from "./data-storage.server.js";
 import { getAuthInfo, getClientId, getPreferences } from "./db.server.js";
-import { getEpicVideoInfos } from "./epic-api.server.js";
+import { getEpicVideoInfos, getEpicVideoMetadata, normalizeVideoApiHost, } from "./epic-api.server.js";
 import { getEnv } from "./init-env.js";
 import { logger } from "./logger.js";
 import { OFFLINE_VIDEO_CRYPTO_VERSION, createOfflineVideoCipher, createOfflineVideoDecipher, createOfflineVideoIv, createOfflineVideoSalt, decodeOfflineVideoIv, deriveOfflineVideoKey, encodeOfflineVideoIv, getCryptoRange, incrementIv, } from "./offline-video-crypto.server.js";
-const offlineVideoDownloadResolutions = [
-    'best',
-    'high',
-    'medium',
-    'low',
-];
+import { getPreferredDownloadSize, offlineVideoDownloadResolutions, videoDownloadQualityOrder, } from "./offline-video-utils.js";
 function isOfflineVideoDownloadResolution(value) {
     return (typeof value === 'string' &&
         offlineVideoDownloadResolutions.includes(value));
@@ -301,19 +296,29 @@ async function getWorkshopVideoCollection({ request, } = {}) {
     const epicVideoInfos = await getEpicVideoInfos(embedList, { request });
     const videos = [];
     let unavailable = 0;
+    let notDownloadable = 0;
     for (const embed of embedList) {
         const info = epicVideoInfos[embed];
         if (!info || info.status !== 'success') {
             unavailable += 1;
             continue;
         }
+        const downloadSizes = Array.isArray(info.downloadSizes)
+            ? info.downloadSizes
+            : [];
+        const downloadable = info.downloadsAvailable === true;
+        if (!downloadable) {
+            notDownloadable += 1;
+        }
         videos.push({
             playbackId: info.muxPlaybackId,
             title: info.title ?? embed,
             url: embed,
+            downloadable,
+            downloadSizes,
         });
     }
-    return { videos, totalEmbeds: embedUrls.size, unavailable };
+    return { videos, totalEmbeds: embedUrls.size, unavailable, notDownloadable };
 }
 async function getOfflineVideoDownloadResolution() {
     const preferences = await getPreferences();
@@ -323,21 +328,96 @@ async function getOfflineVideoDownloadResolution() {
     }
     return 'best';
 }
-const muxMp4Variants = {
-    high: (playbackId) => `https://stream.mux.com/${playbackId}/high.mp4`,
-    medium: (playbackId) => `https://stream.mux.com/${playbackId}/medium.mp4`,
-    low: (playbackId) => `https://stream.mux.com/${playbackId}/low.mp4`,
-    source: (playbackId) => `https://stream.mux.com/${playbackId}.mp4`,
-};
-const muxResolutionOrder = {
-    best: ['source', 'high', 'medium', 'low'],
-    high: ['high', 'medium', 'low', 'source'],
-    medium: ['medium', 'low', 'high', 'source'],
-    low: ['low', 'medium', 'high', 'source'],
-};
-function getMuxMp4Urls(playbackId, resolution) {
-    const order = muxResolutionOrder[resolution] ?? muxResolutionOrder.best;
-    return order.map((variant) => muxMp4Variants[variant](playbackId));
+const knownDownloadQualities = new Set([
+    'source',
+    'highest',
+    'high',
+    'medium',
+    'low',
+]);
+function normalizeDownloadQuality(quality) {
+    const normalized = quality.toLowerCase();
+    return knownDownloadQualities.has(normalized)
+        ? normalized
+        : null;
+}
+function sortVideoDownloads(downloads, resolution) {
+    const order = videoDownloadQualityOrder[resolution] ?? videoDownloadQualityOrder.best;
+    const qualityRank = new Map(order.map((quality, index) => [quality, index]));
+    return [...downloads].sort((a, b) => {
+        const aQuality = normalizeDownloadQuality(a.quality);
+        const bQuality = normalizeDownloadQuality(b.quality);
+        const aRank = aQuality
+            ? (qualityRank.get(aQuality) ?? order.length)
+            : order.length + 1;
+        const bRank = bQuality
+            ? (qualityRank.get(bQuality) ?? order.length)
+            : order.length + 1;
+        if (aRank !== bRank)
+            return aRank - bRank;
+        const aWidth = a.width ?? 0;
+        const bWidth = b.width ?? 0;
+        if (aWidth !== bWidth)
+            return bWidth - aWidth;
+        const aBitrate = a.bitrate ?? 0;
+        const bBitrate = b.bitrate ?? 0;
+        return bBitrate - aBitrate;
+    });
+}
+function getVideoApiHost(videoUrl) {
+    try {
+        const host = new URL(videoUrl).host;
+        return normalizeVideoApiHost(host);
+    }
+    catch (error) {
+        log.warn('Unable to parse video URL for metadata', {
+            videoUrl,
+            error: formatDownloadError(error),
+        });
+        return null;
+    }
+}
+async function getVideoDownloadUrls({ playbackId, videoUrl, resolution, accessToken, }) {
+    const host = getVideoApiHost(videoUrl);
+    if (!host) {
+        log.warn('No video API host found for offline download', {
+            playbackId,
+            videoUrl,
+        });
+        return [];
+    }
+    const metadata = await getEpicVideoMetadata({
+        playbackId,
+        host,
+        accessToken,
+    });
+    if (!metadata) {
+        log.warn('Video metadata unavailable for offline download', {
+            playbackId,
+            videoUrl,
+        });
+        return [];
+    }
+    const downloads = metadata.downloads ?? [];
+    if (downloads.length === 0) {
+        log.warn('Video metadata missing downloads for offline download', {
+            playbackId,
+            videoUrl,
+            status: metadata.status,
+        });
+        return [];
+    }
+    const ordered = sortVideoDownloads(downloads, resolution);
+    const urls = ordered.map((download) => download.url).filter(Boolean);
+    if (urls.length === 0) {
+        log.warn('Video metadata has downloads but all URLs are invalid', {
+            playbackId,
+            videoUrl,
+            downloadsCount: downloads.length,
+        });
+        return [];
+    }
+    return urls;
 }
 async function isOfflineVideoReady(index, playbackId, keyId, cryptoVersion, workshop) {
     const entry = index[playbackId];
@@ -358,8 +438,16 @@ async function isOfflineVideoReady(index, playbackId, keyId, cryptoVersion, work
         return false;
     }
 }
-async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, }) {
-    const urls = getMuxMp4Urls(playbackId, resolution);
+async function downloadVideo({ playbackId, filePath, key, iv, resolution, videoUrl, accessToken, }) {
+    const urls = await getVideoDownloadUrls({
+        playbackId,
+        videoUrl,
+        resolution,
+        accessToken,
+    });
+    if (urls.length === 0) {
+        throw new Error(`No download URLs available for ${playbackId}`);
+    }
     let lastError = null;
     const attempts = [];
     emitDownloadProgress({
@@ -369,11 +457,11 @@ async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, })
         status: 'downloading',
     });
     for (const url of urls) {
-        log.info('Attempting mux download', { playbackId, url });
+        log.info('Attempting video download', { playbackId, url });
         const response = await fetch(url).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             lastError = error instanceof Error ? error : new Error(message);
-            log.warn('Mux download request failed', {
+            log.warn('Video download request failed', {
                 playbackId,
                 url,
                 message,
@@ -385,7 +473,7 @@ async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, })
             continue;
         if (!response.ok || !response.body) {
             lastError = new Error(`Failed to download ${playbackId} from ${url} (${response.status})`);
-            log.warn('Mux download response not ok', {
+            log.warn('Video download response not ok', {
                 playbackId,
                 url,
                 status: response.status,
@@ -435,7 +523,7 @@ async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, })
             totalBytes: stat.size,
             status: 'complete',
         });
-        log.info('Mux download complete', {
+        log.info('Video download complete', {
             playbackId,
             url,
             size: stat.size,
@@ -448,7 +536,7 @@ async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, })
         totalBytes: null,
         status: 'error',
     });
-    log.error('Mux download failed', {
+    log.error('Video download failed', {
         playbackId,
         resolution,
         attempts,
@@ -456,7 +544,7 @@ async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, })
     });
     throw lastError ?? new Error(`Unable to download video ${playbackId}`);
 }
-async function runOfflineVideoDownloads({ videos, index, keyInfo, workshop, resolution, }) {
+async function runOfflineVideoDownloads({ videos, index, keyInfo, workshop, resolution, accessToken, }) {
     for (const video of videos) {
         const updatedAt = new Date().toISOString();
         downloadState.current = {
@@ -484,12 +572,14 @@ async function runOfflineVideoDownloads({ videos, index, keyInfo, workshop, reso
         index[video.playbackId] = entry;
         await writeOfflineVideoIndex(index);
         try {
-            const { size } = await downloadMuxVideo({
+            const { size } = await downloadVideo({
                 playbackId: video.playbackId,
                 filePath: path.join(getOfflineVideoDir(), entry.fileName),
                 key: keyInfo.key,
                 iv,
                 resolution,
+                videoUrl: video.url,
+                accessToken,
             });
             index[video.playbackId] = {
                 ...entry,
@@ -536,29 +626,41 @@ export function getOfflineVideoDownloadState() {
 }
 export async function getOfflineVideoSummary({ request, } = {}) {
     const workshop = getWorkshopIdentity();
-    const { videos, unavailable } = await getWorkshopVideoCollection({ request });
+    const { videos, unavailable, notDownloadable } = await getWorkshopVideoCollection({ request });
     const index = await readOfflineVideoIndex();
+    const resolution = await getOfflineVideoDownloadResolution();
     const keyInfo = await getOfflineVideoKeyInfo({
         userId: null,
         allowUserIdUpdate: false,
     });
     let downloadedVideos = 0;
     let totalBytes = 0;
+    let remainingDownloadBytes = 0;
     for (const video of videos) {
         const entry = index[video.playbackId];
-        if (entry?.status === 'ready' &&
-            keyInfo &&
+        const isDownloaded = Boolean(entry?.status === 'ready' &&
+            keyInfo?.keyId &&
             entry.keyId === keyInfo.keyId &&
             entry.cryptoVersion === keyInfo.config.version &&
-            hasWorkshop(entry, workshop.id)) {
+            hasWorkshop(entry, workshop.id));
+        if (isDownloaded && entry) {
             downloadedVideos += 1;
             totalBytes += entry.size ?? 0;
+            continue;
+        }
+        if (!video.downloadable)
+            continue;
+        const size = getPreferredDownloadSize(video.downloadSizes, resolution);
+        if (typeof size === 'number') {
+            remainingDownloadBytes += size;
         }
     }
     return {
         totalVideos: videos.length,
         downloadedVideos,
         unavailableVideos: unavailable,
+        notDownloadableVideos: notDownloadable,
+        remainingDownloadBytes,
         totalBytes,
         downloadState,
     };
@@ -606,6 +708,7 @@ export async function startOfflineVideoDownload({ request, } = {}) {
             available: 0,
             queued: 0,
             unavailable: 0,
+            notDownloadable: 0,
             alreadyDownloaded: 0,
         };
     }
@@ -615,6 +718,7 @@ export async function startOfflineVideoDownload({ request, } = {}) {
             available: downloadState.total + downloadState.skipped,
             queued: downloadState.total,
             unavailable: 0,
+            notDownloadable: 0,
             alreadyDownloaded: downloadState.skipped,
         };
     }
@@ -631,7 +735,8 @@ export async function startOfflineVideoDownload({ request, } = {}) {
         errors: [],
     };
     const workshop = getWorkshopIdentity();
-    const { videos, unavailable } = await getWorkshopVideoCollection({ request });
+    const { videos, unavailable, notDownloadable } = await getWorkshopVideoCollection({ request });
+    const downloadableVideos = videos.filter((video) => video.downloadable);
     const index = await readOfflineVideoIndex();
     const authInfo = await getAuthInfo();
     const keyInfo = await getOfflineVideoKeyInfo({
@@ -640,20 +745,21 @@ export async function startOfflineVideoDownload({ request, } = {}) {
     });
     if (!keyInfo) {
         log.warn('Offline video download unavailable: missing key info', {
-            available: videos.length,
+            available: downloadableVideos.length,
             unavailable,
         });
         return {
             state: downloadState,
-            available: videos.length,
+            available: downloadableVideos.length,
             queued: 0,
             unavailable,
+            notDownloadable,
             alreadyDownloaded: 0,
         };
     }
     const downloads = [];
     let alreadyDownloaded = 0;
-    for (const video of videos) {
+    for (const video of downloadableVideos) {
         const entry = index[video.playbackId];
         if (entry?.status === 'ready' &&
             entry.keyId === keyInfo.keyId &&
@@ -695,6 +801,7 @@ export async function startOfflineVideoDownload({ request, } = {}) {
             keyInfo,
             workshop,
             resolution,
+            accessToken: authInfo?.tokenSet.access_token,
         }).catch((error) => {
             log.error('Offline video downloads failed', error);
             downloadState.status = 'error';
@@ -703,9 +810,10 @@ export async function startOfflineVideoDownload({ request, } = {}) {
     }
     return {
         state: downloadState,
-        available: videos.length,
+        available: downloadableVideos.length,
         queued: downloads.length,
         unavailable,
+        notDownloadable,
         alreadyDownloaded,
     };
 }
@@ -757,12 +865,14 @@ export async function downloadOfflineVideo({ playbackId, title, url, }) {
     index[playbackId] = entry;
     await writeOfflineVideoIndex(index);
     try {
-        const { size } = await downloadMuxVideo({
+        const { size } = await downloadVideo({
             playbackId,
             filePath: path.join(getOfflineVideoDir(), entry.fileName),
             key: keyInfo.key,
             iv,
             resolution,
+            videoUrl: url,
+            accessToken: authInfo?.tokenSet.access_token,
         });
         index[playbackId] = {
             ...entry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.73.0",
+  "version": "6.74.1",
   "publishConfig": {
     "access": "public"
   },
@@ -32,6 +32,7 @@
       "./playwright.server": "./src/playwright.server.ts",
       "./notifications.server": "./src/notifications.server.ts",
       "./offline-videos.server": "./src/offline-videos.server.ts",
+      "./offline-video-utils": "./src/offline-video-utils.ts",
       "./process-manager.server": "./src/process-manager.server.ts",
       "./test": "./src/test.ts",
       "./request-context.server": "./src/request-context.server.ts",
@@ -142,6 +143,11 @@
       "types": "./dist/offline-videos.server.d.ts",
       "default": "./dist/offline-videos.server.js"
     },
+    "./offline-video-utils": {
+      "import": "./dist/offline-video-utils.js",
+      "types": "./dist/offline-video-utils.d.ts",
+      "default": "./dist/offline-video-utils.js"
+    },
     "./process-manager.server": {
       "import": "./dist/process-manager.server.js",
       "types": "./dist/process-manager.server.d.ts",