eyevinn-channel-engine 5.1.2 → 5.2.0

package/dist/engine/stream_switcher.js

@@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const debug = require("debug")("engine-stream-switcher");
 const crypto = require("crypto");
 const fetch = require("node-fetch");
@@ -50,6 +51,38 @@ class StreamSwitcher {
     getEventId() {
         return this.eventId;
     }
+    /**
+     * Report this channel's event-polling state, used by the global StreamSwitchLoop
+     * to pick an adaptive poll cadence without leaking switcher internals.
+     *
+     * "Mid-event"/ongoing (per #365): the switcher is on a live stream
+     * (this.streamTypeLive === true) and the current scheduleObj is within its
+     * window, i.e. now >= start_time && now < end_time.
+     *
+     * "Near end": an ongoing event whose remaining time is within the switcher's
+     * existing end-of-event guard window (end_time - now <= 10000; see the 10000ms
+     * guard in streamSwitcher()). Derived from that guard rather than a new constant.
+     *
+     * @returns {{ midEvent: boolean, nearEnd: boolean, msUntilEnd: (number|null) }}
+     *   msUntilEnd is null when there is no ongoing event.
+     */
+    getEventPollingState() {
+        const NEAR_END_GUARD_MS = 10000;
+        const scheduleObj = this.timeDiff;
+        if (!this.streamTypeLive || !scheduleObj || scheduleObj.end_time == null || scheduleObj.start_time == null) {
+            return { midEvent: false, nearEnd: false, msUntilEnd: null };
+        }
+        const now = Date.now();
+        if (now < scheduleObj.start_time || now >= scheduleObj.end_time) {
+            return { midEvent: false, nearEnd: false, msUntilEnd: null };
+        }
+        const msUntilEnd = scheduleObj.end_time - now;
+        return {
+            midEvent: true,
+            nearEnd: msUntilEnd <= NEAR_END_GUARD_MS,
+            msUntilEnd,
+        };
+    }
     async abortLiveFeed(session, sessionLive, message) {
         if (this.streamTypeLive) {
             let status = null;
@@ -61,7 +94,7 @@ class StreamSwitcher {
             }
             catch (err) {
                 debug(`Failed to force a switch off live feed: ${err}`);
-                throw new Error(err);
+                throw err instanceof Error ? err : new Error(String(err));
             }
         }
     }
@@ -212,7 +245,7 @@ class StreamSwitcher {
         catch (err) {
             debug(`[${this.sessionId}]: Unexpected failure in Stream Switcher...`);
             console.error(err);
-            throw new Error(err);
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     async _initSwitching(state, session, sessionLive, scheduleObj) {
@@ -273,7 +306,7 @@ class StreamSwitcher {
                     this.eventId = null;
                     debug(`[${this.sessionId}]: [ ERROR Switching from V2L->LIVE ]`);
                     console.error(err);
-                    throw new Error(err);
+                    throw err instanceof Error ? err : new Error(String(err));
                 }
             case SwitcherState.V2L_TO_VOD:
                 try {
@@ -282,7 +315,10 @@ class StreamSwitcher {
                     currVodCounts = await session.getCurrentMediaAndDiscSequenceCount();
                     eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
                     eventAudioSegments = await session.getTruncatedVodAudioSegments(scheduleObj.uri, scheduleObj.duration / 1000);
-                    if (!eventSegments || (this.useDemuxedAudio && !eventAudioSegments)) {
+                    // #382: derive per-source whether THIS VOD actually provided demuxed
+                    // audio, instead of assuming it from the channel-level output flag.
+                    const vodHasDemuxedAudio = this._sourceHasDemuxedAudio(eventAudioSegments);
+                    if (!eventSegments) {
                         debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
                         this.working = false;
                         this.eventId = null;
@@ -292,13 +328,22 @@ class StreamSwitcher {
                     if (this.prerollsCache[this.sessionId] && this.prerollsCache[this.sessionId].isValid) {
                         const prerollSegments = this.prerollsCache[this.sessionId].segments;
                         eventSegments = this._mergeSegments(prerollSegments, eventSegments, true);
-                        if (this.useDemuxedAudio) {
+                        if (this.useDemuxedAudio && vodHasDemuxedAudio) {
                             const prerollAudioSegments = this.prerollsCache[this.sessionId].audioSegments;
                             eventAudioSegments = this._mergeAudioSegments(prerollAudioSegments, eventAudioSegments, true);
                         }
                     }
                     await session.setCurrentMediaAndDiscSequenceCount(currVodCounts.mediaSeq, currVodCounts.discSeq, currVodCounts.audioSeq, currVodCounts.audioDiscSeq);
-                    await session.setCurrentMediaSequenceSegments(eventSegments, 0, true, eventAudioSegments, 0);
+                    // #382: only carry audio segments into the write when THIS VOD actually
+                    // provided demuxed audio. A muxed VOD returns {} from
+                    // getTruncatedVodAudioSegments; passing that through would crash inside
+                    // setCurrentMediaSequenceSegments (Object.keys on an undefined group).
+                    if (this.useDemuxedAudio && vodHasDemuxedAudio) {
+                        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true, eventAudioSegments, 0);
+                    }
+                    else {
+                        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
+                    }
                     this.working = false;
                     debug(`[${this.sessionId}]: [ Switched from V2L->VOD ]`);
                     return false;
@@ -308,7 +353,7 @@ class StreamSwitcher {
                     this.working = false;
                     this.eventId = null;
                     debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
-                    throw new Error(err);
+                    throw err instanceof Error ? err : new Error(String(err));
                 }
             case SwitcherState.LIVE_TO_V2L:
                 try {
@@ -319,10 +364,13 @@ class StreamSwitcher {
                         liveAudioSegments = await sessionLive.getCurrentAudioSequenceSegments();
                     }
                     liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
+                    // #382: derive per-source whether THIS live source actually produced
+                    // demuxed audio, instead of asserting it purely from the channel flag.
+                    const liveHasDemuxedAudio = this.useDemuxedAudio && liveAudioSegments && !this._isEmpty(liveAudioSegments.currMseqSegs);
                     if (scheduleObj && !scheduleObj.duration) {
                         debug(`[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`);
                     }
-                    if (this._isEmpty(liveSegments.currMseqSegs) || (this.useDemuxedAudio && this._isEmpty(liveAudioSegments.currMseqSegs))) {
+                    if (this._isEmpty(liveSegments.currMseqSegs)) {
                         this.working = false;
                         this.streamTypeLive = false;
                         debug(`[${this.sessionId}]: [ Switched from LIVE->V2L ]`);
@@ -333,14 +381,14 @@ class StreamSwitcher {
                         const prerollSegments = this.prerollsCache[this.sessionId].segments;
                         liveSegments.currMseqSegs = this._mergeSegments(prerollSegments, liveSegments.currMseqSegs, false);
                         liveSegments.segCount += prerollSegments.length;
-                        if (this.useDemuxedAudio) {
+                        if (liveHasDemuxedAudio) {
                             const prerollAudioSegments = this.prerollsCache[this.sessionId].audioSegments;
                             liveAudioSegments.currMseqSegs = this._mergeAudioSegments(prerollAudioSegments, liveAudioSegments.currMseqSegs, false);
                             liveAudioSegments.segCount += prerollAudioSegments.length;
                         }
                     }
                     await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq, liveCounts.discSeq, liveCounts.audioSeq, liveCounts.audioDiscSeq);
-                    if (this.useDemuxedAudio) {
+                    if (liveHasDemuxedAudio) {
                         await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount, false, liveAudioSegments.currMseqSegs, liveAudioSegments.segCount);
                     }
                     else {
@@ -358,7 +406,7 @@ class StreamSwitcher {
                     this.working = false;
                     this.eventId = null;
                     debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->V2L ] ${err}`);
-                    throw new Error(err);
+                    throw err instanceof Error ? err : new Error(String(err));
                 }
             case SwitcherState.LIVE_TO_VOD:
                 try {
@@ -370,6 +418,15 @@ class StreamSwitcher {
                     liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
                     eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
                     eventAudioSegments = await session.getTruncatedVodAudioSegments(scheduleObj.uri, scheduleObj.duration / 1000);
+                    // #383: reconcile across a possible muxed<->demuxed boundary at this
+                    // LIVE->VOD switch point. The channel OUTPUT mode is `useDemuxedAudio`;
+                    // each side of the transition may or may not actually carry demuxed
+                    // audio. We only ever write audio into the (demuxed-output) channel when
+                    // the SPECIFIC source being written actually provided demuxed audio, so a
+                    // muxed source crossing into a demuxed channel does not corrupt the audio
+                    // group / audio discontinuity-sequence with empty or mismatched data.
+                    const liveHasDemuxedAudioLTV = this.useDemuxedAudio && liveAudioSegments && !this._isEmpty(liveAudioSegments.currMseqSegs);
+                    const vodHasDemuxedAudioLTV = this.useDemuxedAudio && this._sourceHasDemuxedAudio(eventAudioSegments);
                     if (!eventSegments) {
                         debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
                         this.streamTypeLive = false;
@@ -378,7 +435,7 @@ class StreamSwitcher {
                         return false;
                     }
                     await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq - 1, liveCounts.discSeq - 1, liveCounts.audioSeq - 1, liveCounts.audioDiscSeq - 1);
-                    if (this.useDemuxedAudio) {
+                    if (liveHasDemuxedAudioLTV) {
                         await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount, false, liveAudioSegments.currMseqSegs, liveAudioSegments.segCount);
                     }
                     else {
@@ -388,12 +445,17 @@ class StreamSwitcher {
                     if (this.prerollsCache[this.sessionId] && this.prerollsCache[this.sessionId].isValid) {
                         const prerollSegments = this.prerollsCache[this.sessionId].segments;
                         eventSegments = this._mergeSegments(prerollSegments, eventSegments, true);
-                        if (this.useDemuxedAudio) {
+                        if (vodHasDemuxedAudioLTV) {
                             const prerollAudioSegments = this.prerollsCache[this.sessionId].audioSegments;
                             eventAudioSegments = this._mergeAudioSegments(prerollAudioSegments, eventAudioSegments, true);
                         }
                     }
-                    await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
+                    if (vodHasDemuxedAudioLTV) {
+                        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true, eventAudioSegments, 0);
+                    }
+                    else {
+                        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
+                    }
                     await sessionLive.resetSession();
                     sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
                     this.working = false;
@@ -406,7 +468,7 @@ class StreamSwitcher {
                     this.working = false;
                     this.eventId = null;
                     debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
-                    throw new Error(err);
+                    throw err instanceof Error ? err : new Error(String(err));
                 }
             case SwitcherState.LIVE_TO_LIVE:
                 try {
@@ -416,6 +478,12 @@ class StreamSwitcher {
                     eventSegments = await sessionLive.getCurrentMediaSequenceSegments();
                     eventAudioSegments = await sessionLive.getCurrentAudioSequenceSegments();
                     currLiveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
+                    // #383: reconcile a possible muxed<->demuxed boundary across a LIVE->LIVE
+                    // switch. Only carry the demuxed audio rendition when the outgoing live
+                    // source actually produced one; if it didn't (a muxed source on a demuxed
+                    // channel), skip the audio write so we don't push an empty audio group /
+                    // desync the audio discontinuity-sequence into the next live source.
+                    const liveHasDemuxedAudioLTL = this.useDemuxedAudio && eventAudioSegments && !this._isEmpty(eventAudioSegments.currMseqSegs);
                     await sessionLive.resetSession();
                     await sessionLive.resetLiveStoreAsync(0);
                     // Insert preroll, if available, for current channel
@@ -423,10 +491,10 @@ class StreamSwitcher {
                         const prerollSegments = this.prerollsCache[this.sessionId].segments;
                         this._insertTimedMetadata(prerollSegments, scheduleObj.timedMetadata || {});
                         eventSegments.currMseqSegs = this._mergeSegments(prerollSegments, eventSegments.currMseqSegs, false);
-                        if (this.useDemuxedAudio) {
+                        if (liveHasDemuxedAudioLTL) {
                             const prerollSegmentsAudio = this.prerollsCache[this.sessionId].audioSegments;
                             this._insertTimedMetadataAudio(prerollSegmentsAudio, scheduleObj.timedMetadata || {});
-                            eventSegments.currMseqSegs = this._mergeAudioSegments(prerollSegmentsAudio, eventAudioSegments.currMseqSegs, false);
+                            eventAudioSegments.currMseqSegs = this._mergeAudioSegments(prerollSegmentsAudio, eventAudioSegments.currMseqSegs, false);
                         }
                     }
                     const faild = await sessionLive.setCurrentMediaAndDiscSequenceCount(currLiveCounts.mediaSeq, currLiveCounts.discSeq, currLiveCounts.audioSeq, currLiveCounts.audioDiscSeq);
@@ -434,7 +502,9 @@ class StreamSwitcher {
                         console.error("cound not set switch live-> live", currVodCounts.mediaSeq, currVodCounts.discSeq, currVodCounts.audioSeq, currVodCounts.audioDiscSeq);
                     }
                     await sessionLive.setCurrentMediaSequenceSegments(eventSegments.currMseqSegs);
-                    await sessionLive.setCurrentAudioSequenceSegments(eventAudioSegments.currMseqSegs);
+                    if (liveHasDemuxedAudioLTL) {
+                        await sessionLive.setCurrentAudioSequenceSegments(eventAudioSegments.currMseqSegs);
+                    }
                     liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
                     if (!liveUri) {
                         debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->LIVE ]`);
@@ -452,7 +522,7 @@ class StreamSwitcher {
                     this.working = false;
                     this.eventId = null;
                     debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->LIVE ]`);
-                    throw new Error(err);
+                    throw err instanceof Error ? err : new Error(String(err));
                 }
             default:
                 debug(`[${this.sessionId}]: SwitcherState [${state}] not implemented`);
@@ -473,6 +543,19 @@ class StreamSwitcher {
         }
         return true;
     }
+    /**
+     * Per-source (#382): does THIS loaded VOD/live source actually provide demuxed
+     * audio? Derived from the presence of a non-empty audioSegments structure at
+     * load time, rather than assumed from the channel-level `useDemuxedAudio` flag.
+     *
+     * `useDemuxedAudio` stays the channel-level OUTPUT mode; this signal is the
+     * per-source INPUT fact used for validity/transition checks so a demuxed-output
+     * channel can still ingest a source that lacks demuxed audio (e.g. a muxed VOD)
+     * without flagging it invalid.
+     */
+    _sourceHasDemuxedAudio(audioSegments) {
+        return !ItemIsEmpty(audioSegments);
+    }
     async _validURI(uri) {
         if (!uri) {
             return false;
@@ -630,7 +713,7 @@ class StreamSwitcher {
             return { mediaSegments: prerollSegments, audioSegments: prerollSegmentsAudio };
         }
         catch (err) {
-            throw new Error(err);
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     _createCustomSimpleSegmentList(segmentList, manifestURI) {
@@ -764,9 +847,14 @@ class StreamSwitcher {
             }
             else {
                 storedLength = langs.length;
+                // @ts-ignore -- pre-existing behavior: `startIdx` is `const`; this path
+                // throws at runtime if ever reached. Preserved byte-for-byte in the TS
+                // port (type-only migration, #374) rather than "fixed" here.
                 startIdx++;
             }
         }
+        // @ts-ignore -- pre-existing behavior: `groupIds`/`langs` are block-scoped to
+        // the while body above and are not in scope here. Preserved as-is.
         return { groupId: groupIds[startIdx], lang: langs[idx - storedLength] };
     }
     // Input: hls vod uri. Output: an M3U object.

package/dist/engine/subtitle_slicer.d.ts

@@ -1,8 +1 @@
-export = SubtitleSlicer;
-declare class SubtitleSlicer {
-    vttFiles: {};
-    getVttFile(url: any): Promise<any>;
-    checkTimeStamp(line: any, startTime: any, endTime: any, elapsedtime: any): boolean;
-    streamToString(stream: any): Promise<any>;
-    generateVtt(params: any, _injectedVttFile: any, _injectedPreviousVttFile: any): Promise<string>;
-}
+export {};

package/dist/engine/subtitle_slicer.js

@@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const fetch = require("node-fetch");
 const fs = require("fs");
 class SubtitleSlicer {

package/dist/engine/util.d.ts

@@ -1,29 +1 @@
-export function filterQueryParser(filterQuery: any): {};
-export function applyFilter(profiles: any, filter: any): any;
-export function cloudWatchLog(silent: any, type: any, logEntry: any): void;
-export function m3u8Header(instanceId: any): string;
-export function toHHMMSS(secs: any): string;
-export function logerror(sessionId: any, err: any): void;
-export function timer(ms: any): Promise<any>;
-export class WaitTimeGenerator {
-    constructor(defaultIntervalMs: any, minValue: any);
-    timestamp: Date;
-    prevWaitTime: any;
-    defaultIntervalMs: any;
-    minValue: any;
-    _getWaitTimeFromTimestamp(): number;
-    getWaitTime(plannedTime: any): Promise<any>;
-}
-export function ItemIsEmpty(obj: any): boolean;
-export function findNearestValue(val: any, array: any): any;
-export function isValidUrl(url: any): boolean;
-export function fetchWithRetry(uri: any, opts: any, maxRetries: any, retryDelayMs: any, timeoutMs: any, debug: any): Promise<any>;
-export function codecsFromString(codecs: any): any[];
-export function timeLeft(endTimestamp: any, currentTimestamp: any): string;
-export function findAudioGroupOrLang(val: any, array: any): any;
-export function roundToThreeDecimals(number: any): any;
-export const COMMON_HEADERS: {
-    "Content-Type": string;
-    "Access-Control-Allow-Origin": string;
-    "Cache-Control": string;
-};
+export {};

package/dist/engine/util.js

@@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const { version } = require("../package.json");
 const fetch = require("node-fetch");
 const { AbortController } = require("abort-controller");
@@ -129,7 +130,7 @@ class WaitTimeGenerator {
         }
         const sec = this.timestamp.getSeconds();
         const defaultSec = this.defaultIntervalMs / 1000;
-        const d = parseInt(sec / defaultSec);
+        const d = parseInt((sec / defaultSec));
         const waitSec = defaultSec * (d + 1) - sec;
         return waitSec * 1000;
     }

package/dist/examples/adbreak.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/adbreak.js

@@ -0,0 +1,104 @@
+"use strict";
+/*
+ * Reference implementation showing a channel configured for
+ * HLS-interstitial (SGAI) ad breaks.
+ *
+ * When `adBreak.enabled` is true and an `adServerUri` is configured, the
+ * engine annotates the served manifest with an EXT-X-DATERANGE HLS
+ * interstitial (class `com.apple.hls.interstitial`) at the VOD boundary and
+ * resolves the ad asset from the ad-serving endpoint. If the endpoint cannot
+ * be reached in time (2s), the break falls back to the configured slate.
+ * See `docs/reference.md` for the full field reference.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+class RefAssetManager {
+    assets;
+    pos;
+    constructor(opts) {
+        this.assets = {
+            "1": [
+                {
+                    id: 1,
+                    title: "Tears of Steel",
+                    uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/master.m3u8",
+                },
+                {
+                    id: 2,
+                    title: "VINN",
+                    uri: "https://maitv-vod.lab.eyevinn.technology/VINN.mp4/master.m3u8",
+                },
+            ],
+        };
+        this.pos = { "1": 0 };
+    }
+    getNextVod(vodRequest) {
+        return new Promise((resolve, reject) => {
+            const channelId = vodRequest.playlistId;
+            if (this.assets[channelId]) {
+                const vod = this.assets[channelId][this.pos[channelId]++];
+                if (this.pos[channelId] > this.assets[channelId].length - 1) {
+                    this.pos[channelId] = 0;
+                }
+                resolve({ id: vod.id, title: vod.title, uri: vod.uri });
+            }
+            else {
+                reject("Invalid channelId provided");
+            }
+        });
+    }
+}
+class RefChannelManager {
+    channels;
+    constructor() {
+        this.channels = [
+            {
+                id: "1",
+                profile: this._getProfile(),
+                // Per-channel ad-break configuration. Overrides the engine-level
+                // `adBreak` default when present.
+                adBreak: {
+                    // Master enable flag. When false (the default) no interstitial
+                    // metadata is emitted and the manifest is unchanged.
+                    enabled: true,
+                    // Ad-serving endpoint queried to fill the break. Must be an
+                    // absolute http(s) URL when enabled. It should answer with JSON
+                    // shaped as { assetUri } | { assetList } | { assets: [...] }.
+                    adServerUri: "https://ad-endpoint.example.com/vast",
+                    // Slate shown while the break is being resolved, and used as the
+                    // fallback if the ad-serving endpoint times out or errors.
+                    slate: {
+                        uri: "https://maitv-vod.lab.eyevinn.technology/slate-consuo.mp4/master.m3u8",
+                        repetitions: 10,
+                        duration: 4000,
+                    },
+                },
+            },
+        ];
+    }
+    getChannels() {
+        return this.channels;
+    }
+    _getProfile() {
+        return [
+            { bw: 6134000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [1024, 458] },
+            { bw: 2323000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [640, 286] },
+            { bw: 1313000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [480, 214] },
+        ];
+    }
+}
+const refAssetManager = new RefAssetManager();
+const refChannelManager = new RefChannelManager();
+const engineOptions = {
+    heartbeat: "/",
+    averageSegmentDuration: 2000,
+    channelManager: refChannelManager,
+    defaultSlateUri: "https://maitv-vod.lab.eyevinn.technology/slate-consuo.mp4/master.m3u8",
+    slateRepetitions: 10,
+    // Engine-level default applied to channels that do not carry their own
+    // `adBreak`. Left disabled here so only channel "1" opens ad breaks.
+    adBreak: { enabled: false },
+};
+const engine = new index_1.ChannelEngine(refAssetManager, engineOptions);
+engine.start();
+engine.listen(process.env.PORT || 8000);

package/dist/index.d.ts

@@ -1 +1 @@
-export { ChannelEngine, ChannelEngineOpts, IAssetManager, IChannelManager, IStreamSwitchManager, VodResponse, VodRequest, Channel, ChannelProfile, AudioTracks, SubtitleTracks, Schedule, } from "./engine/server";
+export { ChannelEngine, ChannelEngineOpts, AdBreakOpts, SlateOpts, IAssetManager, IChannelManager, IStreamSwitchManager, VodResponse, VodRequest, Channel, ChannelProfile, AudioTracks, SubtitleTracks, Schedule, } from "./engine/server";

package/dist/package.json

@@ -1,12 +1,14 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "5.1.2",
+  "version": "5.2.0",
   "description": "OTT TV Channel Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc --project ./ && cp ./package.json dist/",
     "debug-server": "DEBUG=engine-*,vod-to-live node dist/server.js",
+    "typecheck:spec": "tsc --project ./tsconfig.spec.json",
+    "pretest": "npm run typecheck:spec",
     "test": "jasmine",
     "version:rc": "npm version prerelease --preid=rc",
     "postversion": "git push && git push --tags",
@@ -16,7 +18,7 @@
     "start-livemix-demux": "node dist/examples/livemix-demux.js"
   },
   "engines": {
-    "node": ">=20"
+    "node": "^22.23.4 || >=24.22.1"
   },
   "author": "Eyevinn Technology AB <work@eyevinn.se>",
   "contributors": [
@@ -36,18 +38,32 @@
     "@eyevinn/hls-truncate": "^0.4.0",
     "@eyevinn/hls-vodtolive": "^4.1.10",
     "@eyevinn/m3u8": "^0.5.6",
-    "@fastify/static": "^9.1.1",
+    "@fastify/static": "^10.1.2",
     "abort-controller": "^3.0.0",
     "debug": "^3.2.7",
-    "fastify": "^5.0.0",
+    "fastify": "^5.12.1",
     "ioredis": "^5.3.2",
     "memcache-client": "^0.10.1",
     "node-fetch": "^2.6.1",
     "promise.allsettled": "^1.0.4",
     "uuid": "^14.0.0"
   },
+  "overrides": {
+    "fast-uri": "^3.1.6",
+    "@eyevinn/hls-truncate": {
+      "node-fetch": "^2.6.7"
+    },
+    "@fastify/static": {
+      "brace-expansion": "^5.0.12"
+    },
+    "jasmine": {
+      "brace-expansion": "^1.1.21"
+    }
+  },
   "devDependencies": {
+    "@types/jasmine": "^3.10.19",
     "@types/node": "^22.0.0",
+    "@types/uuid": "^10.0.0",
     "jasmine": "^3.1.0",
     "nock": "^13.1.1",
     "typescript": "^5.0.0",