@norskvideo/norsk-studio-built-ins 1.19.0 → 1.26.0-2025-02-19-e81e84b9

package/lib/output.autoCmaf/runtime.d.ts

@@ -1,52 +1,35 @@
-import { AdMarker, AutoProcessorMediaNode, CmafDestinationSettings, CmafMultiVariantOutputNode, Norsk, StreamKey } from '@norskvideo/norsk-sdk';
-import { CreatedMediaNode, OnCreated, ServerComponentDefinition, StudioNodeSubscriptionSource, StudioRuntime } from '@norskvideo/norsk-studio/lib/extension/runtime-types';
+import { AdMarker, AutoProcessorMediaNode, CmafDestinationSettings, CmafMultiVariantOutputNode, HlsTsMultiVariantOutputNode, Norsk, StreamKey } from '@norskvideo/norsk-sdk';
+import { CreatedMediaNode, InstanceRouteInfo, OnCreated, ServerComponentDefinition, ServerComponentSchemas, StudioNodeSubscriptionSource, StudioRuntime } from '@norskvideo/norsk-studio/lib/extension/runtime-types';
 import { CustomSinkNode } from '@norskvideo/norsk-studio/lib/extension/base-nodes';
-import { ReportBuilder } from '@norskvideo/norsk-studio/lib/runtime/execution';
-import { AxinomConfig, EzDrmConfig } from '@norskvideo/norsk-studio/lib/shared/config';
 import { CryptoDetails } from '../shared/drm/cpix';
 import { ContextPromiseControl } from '@norskvideo/norsk-studio/lib/runtime/util';
-export type AutoCmafS3Destination = {
-    host: string;
-    prefix: string;
-    includeAdInsertions: boolean;
-};
-export type AutoCmafConfig = {
-    id: string;
-    displayName: string;
-    name: string;
-    sessionId: boolean;
-    segments: AutoCmafSegment;
-    s3Destinations: AutoCmafS3Destination[];
-    drmProvider?: 'ezdrm' | 'axinom';
-    __global: {
-        ezdrmConfig?: EzDrmConfig;
-        axinomConfig?: AxinomConfig;
-    };
-};
-export type AutoCmafSegment = {
-    retentionPeriod: number;
-    defaultSegmentCount?: number;
-    targetSegmentDuration: number;
-    targetPartDuration: number;
-    holdBackSegments?: number;
-    holdBackParts?: number;
-};
-export type CmafOutputState = {
+import { components } from './types';
+export type AutoCmafAkamaiDestinaton = components['schemas']['AutoCmafAkamaiDestination'];
+export type AutoCmafS3Destination = components['schemas']['AutoCmafS3Destination'];
+export type AutoCmafDestination = AutoCmafAkamaiDestinaton | AutoCmafS3Destination;
+export type InitialState = components['schemas']['InitialState'];
+export type AutoCmafConfig = components['schemas']['AutoCmafConfig'];
+export type AutoCmafConfigExtended = components['schemas']['AutoCmafConfigExtended'];
+export type AutoCmafSegment = components['schemas']['AutoCmafSegment'];
+export type CmafOutputState = components['schemas']['CmafOutputState'];
+export type CmafOutputEvent = {
+    type: 'url-published' | 'output-enabled' | 'output-disabled';
     url?: string;
     drmToken?: string;
 };
-export type CmafOutputEvent = {
-    type: 'url-published';
-    url: string;
-    drmToken?: string;
+export type CmafOutputCommand = {
+    type: 'enable-output' | 'disable-output';
 };
-export type CmafOutputCommand = object;
 export default class AutoCmafDefinition implements ServerComponentDefinition<AutoCmafConfig, AutoCmaf, CmafOutputState, CmafOutputCommand, CmafOutputEvent> {
-    create(norsk: Norsk, cfg: AutoCmafConfig, cb: OnCreated<AutoCmaf>, { updates, report }: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>): Promise<void>;
+    create(norsk: Norsk, cfg: AutoCmafConfig, cb: OnCreated<AutoCmaf>, runtime: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>): Promise<void>;
+    createImpl(norsk: Norsk, cfg: AutoCmafConfigExtended, cb: OnCreated<AutoCmaf>, runtime: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>): Promise<void>;
+    handleCommand(node: AutoCmaf, command: CmafOutputCommand): Promise<void>;
+    instanceRoutes(): Promise<InstanceRouteInfo<AutoCmafConfig, AutoCmaf, CmafOutputState, CmafOutputCommand, CmafOutputEvent>[]>;
+    schemas(): Promise<ServerComponentSchemas>;
 }
 export declare class AutoCmaf extends CustomSinkNode {
     norsk: Norsk;
-    cfg: AutoCmafConfig;
+    cfg: AutoCmafConfigExtended;
     currentSources: Map<CreatedMediaNode, StudioNodeSubscriptionSource>;
     currentMedia: {
         node: AutoProcessorMediaNode<string>;
@@ -55,11 +38,11 @@ export declare class AutoCmaf extends CustomSinkNode {
     }[];
     crypto?: CryptoDetails;
     control: ContextPromiseControl;
-    mv?: CmafMultiVariantOutputNode;
+    mv?: CmafMultiVariantOutputNode | HlsTsMultiVariantOutputNode;
     defaultProgramNumber: number;
     defaultSourceName: string;
     currentMultiVariants: {
-        node?: CmafMultiVariantOutputNode;
+        node?: CmafMultiVariantOutputNode | HlsTsMultiVariantOutputNode;
         programNumber: number;
         sourceName: string;
     }[];
@@ -67,10 +50,13 @@ export declare class AutoCmaf extends CustomSinkNode {
     sessionId?: string;
     destinations: CmafDestinationSettings[];
     advertDestinations: string[];
-    report: ReportBuilder;
-    static create(norsk: Norsk, cfg: AutoCmafConfig, report: ReportBuilder): Promise<AutoCmaf>;
-    constructor(cfg: AutoCmafConfig, norsk: Norsk, report: ReportBuilder);
+    runtime: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>;
+    enabled: boolean;
+    static create(norsk: Norsk, cfg: AutoCmafConfigExtended, runtime: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>): Promise<AutoCmaf>;
+    constructor(cfg: AutoCmafConfigExtended, norsk: Norsk, runtime: StudioRuntime<CmafOutputState, CmafOutputCommand, CmafOutputEvent>);
     initialise(): Promise<void>;
+    enableOutput(): Promise<void>;
+    disableOutput(): Promise<void>;
     handleContext(): Promise<void>;
     subscribe(subs: StudioNodeSubscriptionSource[]): void;
 }

package/lib/output.autoCmaf/runtime.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoCmaf = void 0;
 const norsk_sdk_1 = require("@norskvideo/norsk-sdk");
@@ -8,16 +11,112 @@ const logging_1 = require("@norskvideo/norsk-studio/lib/server/logging");
 const ezdrm_1 = require("../shared/drm/ezdrm");
 const axinom_1 = require("../shared/drm/axinom");
 const util_2 = require("@norskvideo/norsk-studio/lib/runtime/util");
+const promises_1 = __importDefault(require("fs/promises"));
+const json_refs_1 = require("json-refs");
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+function coreInfo(path, op) {
+    return {
+        url: path,
+        summary: op.summary,
+        description: op.description,
+        requestBody: op.requestBody,
+        responses: op.responses,
+    };
+}
+function post(path, paths) {
+    return {
+        ...coreInfo(path, paths[path]['post']),
+        method: 'POST',
+    };
+}
 class AutoCmafDefinition {
-    async create(norsk, cfg, cb, { updates, report }) {
-        const node = await AutoCmaf.create(norsk, cfg, report);
+    async create(norsk, cfg, cb, runtime) {
+        return this.createImpl(norsk, { mode: 'cmaf', ...cfg }, cb, runtime);
+    }
+    async createImpl(norsk, cfg, cb, runtime) {
+        const node = await AutoCmaf.create(norsk, cfg, runtime);
         cb(node);
-        const mv = node.mv;
-        if (mv) {
-            report.registerOutput(cfg.id, mv.url);
-            updates.raiseEvent({ type: 'url-published', url: mv.url, drmToken: node.crypto?.token });
+    }
+    async handleCommand(node, command) {
+        switch (command.type) {
+            case 'enable-output':
+                await node.enableOutput();
+                break;
+            case 'disable-output':
+                await node.disableOutput();
+                break;
+            default:
+                (0, util_1.assertUnreachable)(command.type);
         }
     }
+    async instanceRoutes() {
+        const types = await promises_1.default.readFile(path_1.default.join(__dirname, 'types.yaml'));
+        const root = yaml_1.default.parse(types.toString());
+        const resolved = await (0, json_refs_1.resolveRefs)(root, {}).then((r) => r.resolved);
+        const paths = resolved.paths;
+        function waitFor(condition, finish) {
+            if (condition()) {
+                return finish();
+            }
+            setTimeout(() => {
+                waitFor(condition, finish);
+            }, 10);
+        }
+        return [
+            {
+                ...post('/enable', paths),
+                handler: ({ runtime }) => async (_req, res) => {
+                    try {
+                        const state = runtime.updates.latest();
+                        if (state.enabled) {
+                            return res.status(400).json({ error: 'Output is already enabled' });
+                        }
+                        runtime.updates.sendCommand({
+                            type: 'enable-output'
+                        });
+                        waitFor(() => runtime.updates.latest().enabled, () => {
+                            res.sendStatus(204);
+                        });
+                    }
+                    catch (error) {
+                        console.error('Error in enable handler:', error);
+                        res.status(500).json({ error: 'Failed to enable output' });
+                    }
+                }
+            },
+            {
+                ...post('/disable', paths),
+                handler: ({ runtime }) => async (_req, res) => {
+                    try {
+                        const state = runtime.updates.latest();
+                        if (!state.enabled) {
+                            return res.status(400).json({ error: 'Output is already disabled' });
+                        }
+                        runtime.updates.sendCommand({
+                            type: 'disable-output'
+                        });
+                        waitFor(() => !runtime.updates.latest().enabled, () => {
+                            res.sendStatus(204);
+                        });
+                    }
+                    catch (error) {
+                        console.error('Error in disable handler:', error);
+                        res.status(500).json({ error: 'Failed to disable output' });
+                    }
+                }
+            }
+        ];
+    }
+    async schemas() {
+        const types = await promises_1.default.readFile(path_1.default.join(__dirname, 'types.yaml'));
+        const root = yaml_1.default.parse(types.toString());
+        const resolved = await (0, json_refs_1.resolveRefs)(root, {}).then((r) => r.resolved);
+        return {
+            config: resolved.components.schemas['AutoCmafConfig'],
+            state: resolved.components.schemas['CmafOutputState']
+        };
+    }
 }
 exports.default = AutoCmafDefinition;
 class AutoCmaf extends base_nodes_1.CustomSinkNode {
@@ -35,17 +134,22 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
     sessionId;
     destinations;
     advertDestinations = [];
-    report;
-    static async create(norsk, cfg, report) {
-        const node = new AutoCmaf(cfg, norsk, report);
+    runtime;
+    enabled = true;
+    static async create(norsk, cfg, runtime) {
+        const node = new AutoCmaf(cfg, norsk, runtime);
         await node.initialised;
         return node;
     }
-    constructor(cfg, norsk, report) {
+    constructor(cfg, norsk, runtime) {
         super(cfg.id);
         this.cfg = cfg;
         this.norsk = norsk;
-        this.report = report;
+        this.runtime = runtime;
+        this.enabled = cfg.initialState == 'enabled';
+        if (!this.enabled) {
+            runtime.updates.raiseEvent({ type: 'output-disabled' });
+        }
         if (this.cfg.sessionId) {
             this.sessionId = (Math.random() + 1).toString(36).substring(7);
         }
@@ -57,9 +161,9 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             holdBackSeconds: (cfg.segments.holdBackSegments ?? 3) * cfg.segments.targetSegmentDuration,
             partHoldBackSeconds: (cfg.segments.holdBackParts ?? 3) * cfg.segments.targetPartDuration,
             sessionId: this.sessionId,
-            id: 'local'
+            id: `local-${this.id}`
         });
-        cfg.s3Destinations.forEach((d, i) => {
+        cfg.destinations.filter((d) => d.type == 's3').forEach((d, i) => {
             let sanitisedPrefix = d.prefix;
             if (sanitisedPrefix == "") {
                 sanitisedPrefix = "/";
@@ -70,7 +174,7 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                 if (!sanitisedPrefix.endsWith("/"))
                     sanitisedPrefix = sanitisedPrefix + "/";
             }
-            const id = `s3-${i}`;
+            const id = `s3-${i}-${this.id}`;
             this.destinations.push({
                 id,
                 type: 's3',
@@ -87,6 +191,22 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                 this.advertDestinations.push(id);
             }
         });
+        cfg.destinations.filter((d) => d.type == 'akamai').forEach((d, i) => {
+            const id = `akamai-${i}-${this.id}`;
+            const url = new URL(d.ingest);
+            this.destinations.push({
+                id,
+                type: 'generic',
+                host: url.host,
+                port: url.port ? parseInt(url.port, 10) : 80,
+                pathPrefix: url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`,
+                retentionPeriodSeconds: cfg.segments.retentionPeriod,
+            });
+            if (d.includeAdInsertions) {
+                this.advertDestinations.push(id);
+            }
+        });
+        this.advertDestinations.push('local');
         this.initialised = this.initialise();
     }
     async initialise() {
@@ -105,16 +225,55 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             ].join("\n"),
             mpdAdditions: "",
         } : {};
-        const mv = await this.norsk.output.cmafMultiVariant({
-            id: `${this.cfg.id}-multivariant`,
-            playlistName: this.cfg.name,
-            destinations: this.destinations,
-            ...mvCryptoSettings,
-        });
-        this.setup({ sink: mv });
-        this.mv = mv;
+        if (this.cfg.mode == 'cmaf') {
+            const cmaf = await this.norsk.output.cmafMultiVariant({
+                id: `${this.cfg.id}-multivariant-cmaf`,
+                playlistName: this.cfg.name,
+                destinations: this.destinations,
+                ...mvCryptoSettings,
+            });
+            this.setup({ sink: cmaf });
+            this.mv = cmaf;
+        }
+        else {
+            const ts = await this.norsk.output.hlsTsMultiVariant({
+                id: `${this.cfg.id}-multivariant-ts`,
+                playlistName: this.cfg.name,
+                destinations: this.destinations,
+                ...mvCryptoSettings,
+            });
+            this.setup({ sink: ts });
+            this.mv = ts;
+        }
+        this.runtime.report.registerOutput(this.cfg.id, this.mv.url);
+        this.runtime.updates.raiseEvent({ type: 'url-published', url: this.mv.url, drmToken: this.crypto?.token });
+    }
+    async enableOutput() {
+        if (!this.enabled) {
+            (0, logging_1.debuglog)("Enabling output", { id: this.id });
+            this.enabled = true;
+            await this.control.schedule();
+            this.runtime.updates.raiseEvent({ type: 'output-enabled' });
+            (0, logging_1.debuglog)("Output enabled", { id: this.id });
+        }
+    }
+    async disableOutput() {
+        if (this.enabled) {
+            (0, logging_1.debuglog)("Disabling output", { id: this.id });
+            this.enabled = false;
+            for (const media of this.currentMedia) {
+                await media.node?.close();
+            }
+            this.runtime.updates.raiseEvent({ type: 'output-disabled' });
+            this.currentMedia = [];
+            (0, logging_1.debuglog)("output disabled", { id: this.id });
+        }
     }
     async handleContext() {
+        if (!this.enabled) {
+            (0, logging_1.debuglog)("Skipping context handling - output disabled", { id: this.id });
+            return;
+        }
         const streams = [];
         this.currentSources.forEach((subscription) => {
             for (const stream of subscription.latestStreams()) {
@@ -136,23 +295,35 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                 this.defaultProgramNumber = stream.key.programNumber;
                 this.defaultSourceName = stream.key.sourceName;
             }
-            if (!this.currentMultiVariants.find((v) => v.programNumber == stream.key.programNumber && v.sourceName == stream.key.sourceName)) {
-                const newMv = {
-                    programNumber: stream.key.programNumber,
-                    sourceName: stream.key.sourceName,
-                    node: undefined
-                };
-                this.currentMultiVariants.push(newMv);
-                const mv = await this.norsk.output.cmafMultiVariant({
-                    id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}`,
-                    playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
-                    destinations: this.destinations
-                });
-                (0, logging_1.debuglog)("Creating program-specific multi-variant in AutoCMAF", { id: this.id, streamKey: stream.key });
-                newMv.node = mv;
-                this.report.registerOutput(this.cfg.id, mv.url);
+            if (this.cfg.multiplePrograms) {
+                if (!this.currentMultiVariants.find((v) => v.programNumber == stream.key.programNumber && v.sourceName == stream.key.sourceName)) {
+                    const newMv = {
+                        programNumber: stream.key.programNumber,
+                        sourceName: stream.key.sourceName,
+                        node: undefined,
+                    };
+                    this.currentMultiVariants.push(newMv);
+                    (0, logging_1.debuglog)("Creating program-specific multi-variant in AutoPlaylist", { id: this.id, streamKey: stream.key });
+                    if (this.cfg.mode == 'cmaf') {
+                        newMv.node = await this.norsk.output.cmafMultiVariant({
+                            id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}-cmaf`,
+                            playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
+                            destinations: this.destinations
+                        });
+                        this.runtime.report.registerOutput(this.cfg.id, newMv.node.url);
+                    }
+                    else {
+                        newMv.node = await this.norsk.output.cmafMultiVariant({
+                            id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}-ts`,
+                            playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
+                            destinations: this.destinations
+                        });
+                        this.runtime.report.registerOutput(this.cfg.id, newMv.node.url);
+                    }
+                }
             }
             const streamKeyString = `${stream.key.sourceName}-${stream.key.programNumber}-${stream.key.streamId}-${stream.key.renditionName}`;
+            (0, logging_1.debuglog)("Setting up media nodes for key", { id: this.id, key: stream.key, type: stream.metadata.message.case });
             switch (stream.metadata.message.case) {
                 case undefined:
                     throw "Bad server message";
@@ -162,29 +333,48 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                         m3uAdditions: this.crypto.video.mediaSignaling,
                         mpdAdditions: this.crypto.video.dashSignalling,
                     } : {};
-                    const video = await this.norsk.output.cmafVideo({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        partDurationSeconds: this.cfg.segments.targetPartDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-video`,
-                        ...videoCryptoSettings,
-                    });
-                    subscribes.push(new Promise((resolve, _reject) => {
-                        video.subscribe([{
-                                source: stream.source,
-                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                            }], (_) => true, (_) => resolve({}));
-                    }));
+                    let node = undefined;
+                    if (this.cfg.mode == 'cmaf') {
+                        const local = node = await this.norsk.output.cmafVideo({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            partDurationSeconds: this.cfg.segments.targetPartDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-video-cmaf`,
+                            ...videoCryptoSettings,
+                        });
+                        local.onPlaylistAddition = (_, p) => p;
+                        local.onPlaylistAddition = undefined;
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    else {
+                        const local = node = await this.norsk.output.hlsTsVideo({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-video-ts`,
+                            ...videoCryptoSettings,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
                     const newMedia = {
                         key: stream.key,
-                        node: video,
+                        node,
                         scheduleAd: (ad, destinationId) => {
                             const now = new Date();
-                            video.scheduleTag(ad, now, destinationId);
+                            node?.scheduleTag(ad, now, destinationId);
                         }
                     };
                     this.currentMedia.push(newMedia);
-                    this.registerInput(video);
+                    this.registerInput(node);
                     break;
                 }
                 case "audio": {
@@ -193,51 +383,74 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                         m3uAdditions: this.crypto.audio.mediaSignaling,
                         mpdAdditions: this.crypto.audio.dashSignalling,
                     } : {};
-                    const audio = await this.norsk.output.cmafAudio({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        partDurationSeconds: this.cfg.segments.targetPartDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-audio`,
-                        ...audioCryptoSettings,
-                    });
-                    subscribes.push(new Promise((resolve, _reject) => {
-                        audio.subscribe([{
-                                source: stream.source,
-                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                            }], (_) => true, (_) => resolve({}));
-                    }));
+                    let node = undefined;
+                    if (this.cfg.mode == 'cmaf') {
+                        const local = node = await this.norsk.output.cmafAudio({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            partDurationSeconds: this.cfg.segments.targetPartDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-audio-cmaf`,
+                            ...audioCryptoSettings,
+                        });
+                        local.onPlaylistAddition = (_, p) => p;
+                        local.onPlaylistAddition = undefined;
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    else {
+                        const local = node = await this.norsk.output.hlsTsAudio({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-audio-ts`,
+                            ...audioCryptoSettings,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
                     const newMedia = {
                         key: stream.key,
-                        node: audio,
+                        node,
                         scheduleAd: (ad, destinationId) => {
                             const now = new Date();
-                            audio.scheduleTag(ad, now, destinationId);
+                            node?.scheduleTag(ad, now, destinationId);
                         }
                     };
                     this.currentMedia.push(newMedia);
-                    this.registerInput(audio);
+                    this.registerInput(node);
                     break;
                 }
                 case "subtitle": {
-                    const subtitle = await this.norsk.output.cmafWebVtt({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-webvtt`
-                    });
-                    subtitle.subscribe([{
-                            source: stream.source,
-                            sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                        }]);
-                    const newMedia = {
-                        key: stream.key,
-                        node: subtitle,
-                        scheduleAd: (ad, destinationId) => {
-                            const now = new Date();
-                            subtitle.scheduleTag(ad, now, destinationId);
-                        }
-                    };
-                    this.currentMedia.push(newMedia);
-                    this.registerInput(subtitle);
+                    if (this.cfg.mode == 'cmaf') {
+                        const subtitleCmaf = await this.norsk.output.cmafWebVtt({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-webvtt`,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            subtitleCmaf.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                        const newMedia = {
+                            key: stream.key,
+                            node: subtitleCmaf,
+                            scheduleAd: (ad, destinationId) => {
+                                const now = new Date();
+                                subtitleCmaf.scheduleTag(ad, now, destinationId);
+                            }
+                        };
+                        this.currentMedia.push(newMedia);
+                        this.registerInput(subtitleCmaf);
+                    }
                     break;
                 }
                 case "ancillary": {
@@ -257,16 +470,18 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                                         id: adId,
                                         scte35: message,
                                         startDate: schedule,
-                                        durationSeconds: Number(command.breakDuration.duration / BigInt(90000.0))
+                                        durationSeconds: Number((command.breakDuration?.duration ?? 0n) / BigInt(90000.0))
                                     }, d);
                                 }
                             }
                         }
                     });
-                    ancillary.subscribe([{
-                            source: stream.source,
-                            sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                        }]);
+                    subscribes.push(new Promise((resolve, _reject) => {
+                        ancillary.subscribe([{
+                                source: stream.source,
+                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                            }], (_) => true, (_) => resolve({}));
+                    }));
                     this.registerInput(ancillary);
                     break;
                 }
@@ -285,11 +500,13 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
         for (const deletion of deletions) {
             const node = deletion.node;
             this.currentMedia = this.currentMedia.filter((x) => !(0, norsk_sdk_1.streamKeysAreEqual)(x.key, deletion.key));
-            await node.close();
+            (0, logging_1.debuglog)("Closing old media node for non-existant key", { id: this.id, key: deletion.key });
+            await node?.close();
         }
+        (0, logging_1.debuglog)("Waiting for media playlists to be created", { id: this.id, count: creations.length });
         await Promise.all(creations);
         const defaultSources = this.currentMedia.flatMap((m) => {
-            if (m.key.programNumber == this.defaultProgramNumber && m.key.sourceName == this.defaultSourceName && m.node)
+            if (m.key.programNumber == this.defaultProgramNumber && m.key.sourceName == this.defaultSourceName)
                 return [{ source: m.node, sourceSelector: norsk_sdk_1.selectPlaylist }];
             return [];
         });
@@ -298,7 +515,8 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             this.defaultProgramNumber = 0;
             this.defaultSourceName = '';
         }
-        this.mv?.subscribe(defaultSources);
+        this.mv?.subscribe(defaultSources.
+            map((s) => ({ source: s.source, sourceSelector: s.sourceSelector })));
         for (const mv of this.currentMultiVariants) {
             const sources = this.currentMedia.flatMap((m) => {
                 if (m.key.programNumber == mv.programNumber && m.key.sourceName == mv.sourceName && m.node)