@norskvideo/norsk-studio-built-ins 1.27.0-2025-03-11-6b63bfb6 → 1.27.0-2025-03-14-ed70a41a

package/client/info.js

@@ -4956,41 +4956,53 @@ var require_client_types = __commonJS({
     exports.RegistrationConsts = exports.Subtitle = exports.Playlist = exports.Video = exports.Audio = exports.Av = exports.All = void 0;
     exports.subscriptionMedia = subscriptionMedia;
     exports.outputMedia = outputMedia;
+    exports.simpleToMedia = simpleToMedia;
+    exports.outputStreamComponents = outputStreamComponents;
     exports.inputMedia = inputMedia;
     exports.discriminatedForm = discriminatedForm3;
-    exports.All = ["video", "audio", "subtitle"];
+    exports.All = ["video", "audio", "subtitle", "ancillary"];
     exports.Av = ["video", "audio"];
     exports.Audio = ["audio"];
     exports.Video = ["video"];
     exports.Playlist = ["playlist"];
     exports.Subtitle = ["subtitle"];
     function subscriptionMedia(s) {
-      return s.streams.select;
+      if (!s)
+        return [];
+      return s.streams.filter.map((f) => f.media);
+    }
+    function outputMedia(s, cfg, inputs) {
+      const components = outputStreamComponents(s, cfg, inputs);
+      return [...new Set(components.map((s2) => s2.media)).values()];
     }
-    function outputMedia(s) {
+    function simpleToMedia(stream) {
+      const keys = Object.keys(stream);
+      return exports.All.filter((media) => {
+        return keys.includes(media);
+      });
+    }
+    function outputStreamComponents(s, cfg, inputs) {
       if (!s)
         return [];
       const t = s.type;
       switch (t) {
-        case "single-stream":
-          return s.media;
-        case "multi-stream":
-          return s.media;
-        case "fixed-list":
-          return s.possibleMedia;
+        case "simple-stream":
+          return simpleToMedia(s).map((media) => ({ media }));
+        case "dynamic-streams":
+          return s.streams(cfg, inputs);
         default:
           (0, util_1.assertUnreachable)(t);
       }
     }
-    function inputMedia(s) {
+    function inputMedia(s, cfg) {
       if (!s)
         return [];
       const t = s.type;
       switch (t) {
-        case "multi-stream":
-          return s.media;
-        case "single-stream":
-          return s.media;
+        case "dynamic-streams":
+          return s.streams(cfg).map((s2) => s2.media);
+        case "simple-stream":
+          return simpleToMedia(s);
         default:
           (0, util_1.assertUnreachable)(t);
       }
@@ -5438,10 +5450,9 @@ function info_default14({ defineComponent, All }) {
     name: "Statistics",
     description: "This component accepts multiple media streams, captures and reports metrics or statistical data related to the media streams.",
     subscription: {
-      // No validation required
       accepts: {
-        type: "multi-stream",
-        media: All
+        type: "dynamic-streams",
+        streams: () => All.map((media) => ({ media }))
       }
     },
     display: (_desc) => {
@@ -20610,18 +20621,9 @@ function info_default({ defineComponent, Av, validation: { Z, Port, SourceName,
     subscription: {
       accepts: void 0,
       produces: {
-        type: "fixed-list",
-        possibleMedia: Av,
-        keys: (cfg) => cfg.streamNames.map((s) => ({
-          key: s,
-          display: s,
-          media: Av
-        })),
-        selector: (selection, metadata) => {
-          return metadata.filter((m) => {
-            return selection.includes(m.streamKey.sourceName);
-          }).map((s) => s.streamKey);
-        }
+        type: "dynamic-streams",
+        groupBy: "sourceName",
+        streams: (cfg) => Av.flatMap((media) => cfg.streamNames.map((s) => ({ media, sourceName: s })))
       }
     },
     display: (desc) => {
@@ -20685,7 +20687,7 @@ function assertUnreachable(_) {
 }
 
 // build/input.silence/info.js
-function info_default2({ defineComponent, Audio }) {
+function info_default2({ defineComponent }) {
   return defineComponent({
     identifier: "input.silence",
     category: "input",
@@ -20693,8 +20695,11 @@ function info_default2({ defineComponent, Audio }) {
     description: "A component that produces silent audio streams with configurable sample rate and channel layout.",
     subscription: {
       produces: {
-        type: "single-stream",
-        media: Audio
+        type: "dynamic-streams",
+        streams: (cfg) => [{
+          sourceName: cfg.id,
+          media: "audio"
+        }]
       }
     },
     display: (desc) => {
@@ -20800,8 +20805,11 @@ function info_default3({ defineComponent, Av, validation }) {
     subscription: {
       accepts: void 0,
       produces: {
-        type: "single-stream",
-        media: Av
+        type: "dynamic-streams",
+        streams: (cfg) => Av.map((media) => ({
+          sourceName: cfg.id,
+          media
+        }))
       }
     },
     display: (desc) => {
@@ -20841,7 +20849,7 @@ function info_default3({ defineComponent, Av, validation }) {
 var import_react3 = __toESM(require_react());
 var InlineView4 = import_react3.default.lazy(async () => Promise.resolve().then(() => (init_inline_view2(), inline_view_exports2)));
 var SummaryView4 = import_react3.default.lazy(async () => Promise.resolve().then(() => (init_summary_view2(), summary_view_exports2)));
-function info_default4({ defineComponent, Av, validation }) {
+function info_default4({ defineComponent, All, validation }) {
   const { Z, Port, Hostname, SourceName, SrtPassphrase, unique } = validation;
   const SocketConfiguration2 = import_react3.default.lazy(async () => {
     const views = await Promise.resolve().then(() => (init_srt_form_views(), srt_form_views_exports));
@@ -20855,18 +20863,9 @@ function info_default4({ defineComponent, Av, validation }) {
     subscription: {
       accepts: void 0,
       produces: {
-        type: "fixed-list",
-        possibleMedia: Av,
-        keys: (cfg) => cfg.streamIds.map((s) => ({
-          key: s,
-          display: s,
-          media: Av
-        })),
-        selector: (selection, metadata) => {
-          return metadata.filter((m) => {
-            return selection.includes(m.streamKey.sourceName);
-          }).map((s) => s.streamKey);
-        }
+        type: "dynamic-streams",
+        groupBy: "sourceName",
+        streams: (cfg) => All.flatMap((media) => cfg.streamIds.map((s) => ({ media, sourceName: s })))
       }
     },
     display: (desc) => {
@@ -20974,7 +20973,7 @@ function assertUnreachable2(_) {
 }
 
 // build/input.udp-ts/info.js
-function info_default5({ defineComponent, Av, validation: { Z, Port, Hostname, SourceName, unique } }) {
+function info_default5({ defineComponent, All, validation: { Z, Port, Hostname, SourceName, unique } }) {
   return defineComponent({
     identifier: "input.udp-ts",
     category: "input",
@@ -20983,8 +20982,11 @@ function info_default5({ defineComponent, Av, validation: { Z, Port, Hostname, S
     subscription: {
       accepts: void 0,
       produces: {
-        type: "single-stream",
-        media: Av
+        type: "dynamic-streams",
+        streams: (cfg) => All.map((media) => ({
+          sourceName: cfg.sourceName,
+          media
+        }))
       }
     },
     display: (desc) => {
@@ -21008,7 +21010,7 @@ function info_default5({ defineComponent, Av, validation: { Z, Port, Hostname, S
 }
 
 // build/input.videoTestCard/info.js
-function info_default6({ defineComponent, Video, validation: { SourceName, unique }, common: { Resolutions, FrameRates } }) {
+function info_default6({ defineComponent, validation: { SourceName, unique }, common: { Resolutions, FrameRates } }) {
   return defineComponent({
     identifier: "input.videoTestCard",
     category: "input",
@@ -21017,8 +21019,11 @@ function info_default6({ defineComponent, Video, validation: { SourceName, uniqu
     subscription: {
       accepts: void 0,
       produces: {
-        type: "single-stream",
-        media: Video
+        type: "dynamic-streams",
+        streams: (cfg) => [{
+          sourceName: cfg.sourceName,
+          media: "video"
+        }]
       }
     },
     display: (desc) => {
@@ -21086,21 +21091,19 @@ function info_default7(R) {
     name: "Auto CMAF",
     description: "This component handles the creation of CMAF outputs from multiple video and audio streams.",
     subscription: {
-      // Again, accept anything
-      // but reject the same stream twice
-      // this is probably important given the amount of places we split audio/video
       accepts: {
-        type: "multi-stream",
-        media: All
+        type: "dynamic-streams",
+        mode: "any",
+        streams: () => All.map((media) => ({ media }))
       }
     },
     extraValidation: (ctx) => {
-      const audioStreams = ctx.subscriptions.filter((s) => s.validatedStreams.select.includes("audio"));
+      const audioStreams = ctx.subscriptions.filter((s) => s.streams.filter.find((f) => f.media == "audio"));
       if (audioStreams.length == 0) {
         ctx.addError("AutoPlaylist requires at least one audio stream");
       }
       const uniqueVideoStreamNodes = ctx.subscriptions.reduce((acc, s) => {
-        if (s.validatedStreams.select.includes("video")) {
+        if (s.streams.filter.find((f) => f.media == "video")) {
           if (!acc.includes(s.source)) {
             acc.push(s.source);
           }
@@ -21403,21 +21406,17 @@ function info_default9(r) {
     }
   });
 }
-function defineRtmpOutputComponent({ defineComponent, Av }, settings) {
+function defineRtmpOutputComponent({ defineComponent }, settings) {
   const SummaryView12 = import_react6.default.lazy(async () => Promise.resolve().then(() => (init_summary_view4(), summary_view_exports4)));
   const InlineView15 = import_react6.default.lazy(async () => Promise.resolve().then(() => (init_inline_view4(), inline_view_exports4)));
   return defineComponent({
     ...settings,
     category: "output",
     subscription: {
-      // No validation?
-      // Accept either *just* audio, or *just* video, or audio *and* video
-      // there can only be one of each though
-      // The selection of these things should determine the subscriptionValidation callback
-      // requireAV or just 'cool cool cool'
       accepts: {
-        type: "single-stream",
-        media: Av
+        type: "simple-stream",
+        audio: true,
+        video: true
       }
     },
     display: (_desc) => {
@@ -21517,7 +21516,7 @@ function info_default11(r) {
 var import_react8 = __toESM(require_react());
 var import_config2 = __toESM(require_config());
 function info_default12(R) {
-  const { defineComponent, Av, validation: { JitterBuffer } } = R;
+  const { defineComponent, validation: { JitterBuffer } } = R;
   const InlineView15 = import_react8.default.lazy(async () => Promise.resolve().then(() => (init_inline_view5(), inline_view_exports5)));
   return defineComponent({
     identifier: "output.preview",
@@ -21526,28 +21525,15 @@ function info_default12(R) {
     description: "Preview allows for the real-time preview of media streams. It provides a way to visualize and monitor the output from various media sources before final processing or distribution.",
     subscription: {
       accepts: {
-        type: "single-stream",
-        media: Av
+        type: "simple-stream",
+        audio: true,
+        video: true
       },
       produces: void 0
     },
     extraValidation: (ctx) => {
-      const video = ctx.subscriptions.filter((s) => s.validatedStreams.select.includes("video"));
-      const audio = ctx.subscriptions.filter((s) => s.validatedStreams.select.includes("audio"));
-      if (video.length == 1 && audio.length == 1)
-        return;
-      if (video.length == 0) {
-        ctx.addError("Preview requires a video subscription in order to work");
-      }
-      if (audio.length == 0) {
-        ctx.addError("Preview requires an audio subscription in order to work");
-      }
-      if (video.length > 1) {
-        ctx.addError("Preview cannot work with more than one video subscription");
-      }
-      if (audio.length > 1) {
-        ctx.addError("Preview cannot work with more than one audio subscription");
-      }
+      ctx.requireVideo(1);
+      ctx.requireAudio(1);
     },
     display: (_desc) => {
       return {};
@@ -21624,11 +21610,10 @@ function info_default13(registration) {
     name: "SRT Egest",
     description: "This component manages the sending of SRT (Secure Reliable Transport) streams. It allows you to configure various settings to control how the SRT output is handled, including connection details, buffer settings, and delay options.",
     subscription: {
-      // No validation?
-      // Streams have to be unique? That's a stretch goal
       accepts: {
-        type: "multi-stream",
-        media: All
+        type: "dynamic-streams",
+        mode: "any",
+        streams: () => All.map((media) => ({ media }))
       }
     },
     display: (desc) => {
@@ -21753,11 +21738,10 @@ function info_default16({ defineComponent, All, validation: { Port, Hostname, Ji
     name: "UDP TS Egest",
     description: "This component outputs multiple media streams over UDP in TS (Transport Stream) format. It accepts multiple input streams and sends them to a specified IP address and port.",
     subscription: {
-      // Just works with no validation
-      // although uniqueness again, stretch goal
       accepts: {
-        type: "multi-stream",
-        media: All
+        type: "dynamic-streams",
+        mode: "any",
+        streams: () => All.map((media) => ({ media }))
       }
     },
     display: (desc) => {
@@ -21787,7 +21771,7 @@ function info_default16({ defineComponent, All, validation: { Port, Hostname, Ji
 var import_config3 = __toESM(require_config());
 var import_react12 = __toESM(require_react());
 function info_default17(R) {
-  const { defineComponent, Av, validation: { JitterBuffer } } = R;
+  const { defineComponent, validation: { JitterBuffer } } = R;
   const InlineView15 = import_react12.default.lazy(async () => Promise.resolve().then(() => (init_inline_view8(), inline_view_exports8)));
   const SummaryView12 = import_react12.default.lazy(async () => Promise.resolve().then(() => (init_summary_view6(), summary_view_exports6)));
   return defineComponent({
@@ -21796,14 +21780,10 @@ function info_default17(R) {
     name: "WHEP Egest",
     description: "This component allows us to use WebRTC egress for outputs.",
     subscription: {
-      // No validation?
-      // Accept either *just* audio, or *just* video, or audio *and* video
-      // there can only be one of each though
-      // The selection of these things should determine the subscriptionValidation callback
-      // requireAV or just 'cool cool cool'
       accepts: {
-        type: "single-stream",
-        media: Av
+        type: "simple-stream",
+        audio: true,
+        video: true
       }
     },
     display: (_desc) => {
@@ -21882,7 +21862,7 @@ function info_default18(r) {
 // build/processor.audioEncoder/info.js
 var import_client_types2 = __toESM(require_client_types());
 var import_react13 = __toESM(require_react());
-function info_default19({ defineComponent, Audio, validation: { Z } }) {
+function info_default19({ defineComponent, validation: { Z } }) {
   const format = (stat) => Math.floor(stat).toLocaleString("en-US", { maximumFractionDigits: 0 });
   const Hz = (v) => ({ display: `${format(v)}Hz`, value: v });
   return defineComponent({
@@ -21892,12 +21872,12 @@ function info_default19({ defineComponent, Audio, validation: { Z } }) {
     description: "Explicit audio encode.",
     subscription: {
       accepts: {
-        type: "single-stream",
-        media: Audio
+        type: "simple-stream",
+        audio: true
       },
       produces: {
-        type: "single-stream",
-        media: Audio
+        type: "simple-stream",
+        audio: true
       }
     },
     display: ({ config }) => {
@@ -22015,7 +21995,7 @@ var import_config4 = __toESM(require_config());
 var import_react15 = __toESM(require_react());
 var SummaryView10 = import_react15.default.lazy(async () => Promise.resolve().then(() => (init_summary_view7(), summary_view_exports7)));
 var InlineView12 = import_react15.default.lazy(async () => Promise.resolve().then(() => (init_inline_view9(), inline_view_exports9)));
-function info_default20({ defineComponent, Video, validation: { Z } }) {
+function info_default20({ defineComponent, validation: { Z } }) {
   return defineComponent({
     identifier: "processor.browserOverlay",
     category: "processor",
@@ -22024,12 +22004,12 @@ function info_default20({ defineComponent, Video, validation: { Z } }) {
     subscription: {
       // Only accept a single video stream
       accepts: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       },
       produces: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       }
     },
     extraValidation: function(ctx) {
@@ -22086,23 +22066,23 @@ function info_default21({ defineComponent, Av, React: React15, common: { Resolut
     name: "Cascading Switch",
     description: "This component manages multiple A/V (audio and video) sources based on priority, allowing for the configuration of settings such as resolution, frame rate, sample rate, and channel layout.",
     subscription: {
-      // This needs to change anyway
-      // but it'll be the same as MCS
       accepts: {
-        type: "multi-stream",
-        media: Av
+        type: "dynamic-streams",
+        mode: { type: "multiple", groupBy: "sourceName" },
+        streams: () => Av.map((media) => ({ media }))
       },
       produces: {
-        type: "single-stream",
-        media: Av
+        type: "simple-stream",
+        audio: true,
+        video: true
       }
     },
     extraValidation: function(ctx) {
       ctx.subscriptions.forEach((s) => {
-        if (!s.validatedStreams.select.includes("video")) {
+        if (!s.streams.filter.find((f) => f.media == "video")) {
           ctx.addError(`Subscription to ${s.source} is missing video`);
         }
-        if (!s.validatedStreams.select.includes("audio")) {
+        if (!s.streams.filter.find((f) => f.media == "audio")) {
           ctx.addError(`Subscription to ${s.source} is missing audio`);
         }
         if (s.streams.type == "take-all-streams") {
@@ -22217,7 +22197,7 @@ function assertUnreachable10(_) {
 // build/processor.fixedLadder/info.js
 var import_react18 = __toESM(require_react());
 var import_config5 = __toESM(require_config());
-function info_default22({ defineComponent, Video, common: { FrameRates } }) {
+function info_default22({ defineComponent, common: { FrameRates } }) {
   const RungView = import_react18.default.lazy(async () => Promise.resolve().then(() => (init_rung_view(), rung_view_exports)));
   const CodecEditor3 = import_react18.default.lazy(async () => Promise.resolve().then(() => (init_codec_editor(), codec_editor_exports)));
   const CodecView = import_react18.default.lazy(async () => Promise.resolve().then(() => (init_codec_view(), codec_view_exports)));
@@ -22229,24 +22209,12 @@ function info_default22({ defineComponent, Video, common: { FrameRates } }) {
     subscription: {
       // Only accept a single video stream
       accepts: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       },
       produces: {
-        possibleMedia: Video,
-        type: "fixed-list",
-        keys: (cfg) => {
-          return cfg.rungs.map((r) => {
-            return {
-              key: r.name,
-              display: r.name,
-              media: Video
-            };
-          });
-        },
-        selector: (selection, metadata) => {
-          return metadata.filter((s) => s.streamKey && selection.includes(s.streamKey?.renditionName)).map((r) => r.streamKey).filter((r) => !!r);
-        }
+        type: "dynamic-streams",
+        streams: (cfg) => cfg.rungs.map((r) => ({ media: "video", renditionName: r.name }))
       }
     },
     extraValidation: function(ctx) {
@@ -22554,10 +22522,88 @@ function assertUnreachable11(_) {
   throw new Error("Didn't expect to get here");
 }
 
+// build/processor.makeProgram/info.js
+function info_default23({ defineComponent, All, validation: { Z } }) {
+  return defineComponent({
+    identifier: "processor.makeProgram",
+    category: "processor",
+    name: "Make Program",
+    description: "Group unrelated streams together into a single program, incrementing stream-id for each input",
+    subscription: {
+      accepts: {
+        type: "dynamic-streams",
+        mode: "any",
+        streams: () => All.map((media) => ({ media }))
+      },
+      produces: {
+        type: "dynamic-streams",
+        streams: (cfg, inputs) => {
+          return inputs?.map((s, i) => {
+            const output = { ...s };
+            output.programNumber = cfg.programNumber;
+            output.sourceName = cfg.sourceName;
+            output.streamId = cfg.startingStreamId + i;
+            if (cfg.renditionName)
+              output.renditionName = cfg.renditionName;
+            return output;
+          }) ?? [];
+        }
+      }
+    },
+    display: ({ config }) => {
+      const disp = {};
+      disp.sourceName = config.sourceName;
+      disp.programNumber = String(config.programNumber);
+      disp.startingStreamId = String(config.startingStreamId);
+      if (config.renditionName) {
+        disp.renditionName = config.renditionName;
+      }
+      return disp;
+    },
+    extraValidation: (_ctx) => {
+    },
+    configForm: {
+      form: {
+        sourceName: {
+          help: "Source name for the new program",
+          hint: {
+            type: "text",
+            optional: false
+          }
+        },
+        programNumber: {
+          help: "Program number for the new program",
+          hint: {
+            type: "numeric",
+            optional: false,
+            validation: Z.number().min(1).int().optional()
+          }
+        },
+        startingStreamId: {
+          help: "The start stream",
+          hint: {
+            type: "numeric",
+            optional: true,
+            validation: Z.number().min(1).int().optional()
+          }
+        },
+        renditionName: {
+          help: "The rendition name for each stream",
+          hint: {
+            type: "text",
+            optional: true
+          }
+        },
+        notes: { help: "Notes about this component", hint: { type: "text", optional: true } }
+      }
+    }
+  });
+}
+
 // build/processor.onscreenGraphic/info.js
 var import_config6 = __toESM(require_config());
 var import_react21 = __toESM(require_react());
-function info_default23({ defineComponent, Video }) {
+function info_default24({ defineComponent }) {
   const GraphicSelection2 = import_react21.default.lazy(async () => Promise.resolve().then(() => (init_image_selection(), image_selection_exports)));
   const SummaryView12 = import_react21.default.lazy(async () => Promise.resolve().then(() => (init_summary_view8(), summary_view_exports8)));
   return defineComponent({
@@ -22568,12 +22614,12 @@ function info_default23({ defineComponent, Video }) {
     subscription: {
       // Only accept a single video stream
       accepts: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       },
       produces: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       }
     },
     extraValidation: function(ctx) {
@@ -22638,48 +22684,38 @@ function assertUnreachable13(_) {
 }
 
 // build/processor.streamKeyOverride/info.js
-function info_default24({ defineComponent, All, validation: { Z } }) {
+function info_default25({ defineComponent, All, validation: { Z } }) {
   return defineComponent({
     identifier: "processor.streamKeyOverride",
     category: "processor",
     name: "Stream Key Override",
-    description: "Override stream keys for several streams at once, setting some components of the keys and optionally incrementing stream ID.",
+    description: "Override stream keys for several streams at once, optionally setting one or more properties.",
     subscription: {
       accepts: {
-        type: "multi-stream",
-        media: All
+        type: "dynamic-streams",
+        mode: "any",
+        streams: () => All.map((media) => ({ media }))
       },
       produces: {
-        type: "fixed-list",
-        possibleMedia: All,
-        keys: (cfg, subs) => {
-          const outputs = subs.flatMap((sub) => {
-            const sourceNode = sub.document.components[sub.source];
-            if (!sourceNode)
-              return [];
-            const produces = sourceNode.info.subscription.produces;
-            if (produces?.type === "fixed-list") {
-              return produces.keys(sourceNode.config, sourceNode.subscriptions).map((sel) => ({ ...sel, key: `${sourceNode.id}-${sel.key}`, display: `${sourceNode.config.displayName}: ${sel.display}` }));
-            } else {
-              return [{ key: `${sourceNode.id}`, display: `${sourceNode.config.displayName}`, media: produces ? produces.media : All }];
-            }
-          });
-          if (cfg.output === "merged") {
-            const media = Array.from(new Set(outputs.flatMap((x) => x.media)));
-            return [{ key: `merged`, display: "Merged", media }];
-          }
-          return outputs;
-        },
-        selector: () => {
-          console.error("Use selectOutputs from process.streamKeyOverride/runtime.ts, not selector from info.ts");
-          return [];
+        type: "dynamic-streams",
+        streams: (cfg, inputs) => {
+          return inputs?.map((s) => {
+            const output = { ...s };
+            if (cfg.programNumber)
+              output.programNumber = cfg.programNumber;
+            if (cfg.sourceName)
+              output.sourceName = cfg.sourceName;
+            if (cfg.streamId)
+              output.streamId = cfg.streamId;
+            if (cfg.renditionName)
+              output.renditionName = cfg.renditionName;
+            return output;
+          }) ?? [];
         }
       }
     },
     display: ({ config }) => {
       const disp = {};
-      disp.mode = config.mode || "simple";
-      disp.output = config.output || "individually-selectable";
       if (config.sourceName) {
         disp.sourceName = config.sourceName;
       }
@@ -22696,57 +22732,13 @@ function info_default24({ defineComponent, All, validation: { Z } }) {
     },
     extraValidation: (ctx) => {
       const { config, subscriptions } = ctx;
-      if ((config.mode || "simple") == "simple" && config.sourceName && config.programNumber !== void 0 && config.streamId !== void 0 && config.renditionName) {
+      if (config.sourceName && config.programNumber !== void 0 && config.streamId !== void 0 && config.renditionName) {
         if (subscriptions.length > 1)
           ctx.addError("A fully specified stream key override must only subscribe to one stream, or use a mode other than simple");
       }
-      if (config.mode === "by-media-type" && config.streamId === void 0) {
-        ctx.addError("You must specify the starting streamId for a by-media-type stream key override");
-      }
-      if (config.output === "merged" && !config.sourceName) {
-        ctx.addError("You must specify a sourceName for a single merged output");
-      }
     },
     configForm: {
       form: {
-        mode: {
-          help: "Multi-stream behavior",
-          hint: {
-            type: "select",
-            defaultValue: "simple",
-            options: [
-              {
-                display: "Override values directly",
-                value: "simple"
-              },
-              {
-                display: "Increment stream ID by media type (video, audio, ...)",
-                value: "by-media-type"
-              },
-              {
-                display: "Increment stream ID per program in order of subscription",
-                value: "in-order"
-              }
-            ]
-          }
-        },
-        output: {
-          help: "Output individual streams or a single merged stream",
-          hint: {
-            type: "select",
-            defaultValue: "individually-selectable",
-            options: [
-              {
-                display: "Individual inputs can be selected in the output",
-                value: "individually-selectable"
-              },
-              {
-                display: "The outputs are merged into a single stream",
-                value: "merged"
-              }
-            ]
-          }
-        },
         sourceName: {
           help: "Override source name",
           hint: {
@@ -22784,7 +22776,7 @@ function info_default24({ defineComponent, All, validation: { Z } }) {
 }
 
 // build/processor.videoDecoder/info.js
-function info_default25({ defineComponent, Video }) {
+function info_default26({ defineComponent }) {
   return defineComponent({
     identifier: "processor.videoDecoder",
     category: "processor",
@@ -22792,12 +22784,12 @@ function info_default25({ defineComponent, Video }) {
     description: "Explicit video decode.",
     subscription: {
       accepts: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       },
       produces: {
-        type: "single-stream",
-        media: Video
+        type: "simple-stream",
+        video: true
       }
     },
     display: ({ config }) => {
@@ -22831,7 +22823,7 @@ function info_default25({ defineComponent, Video }) {
 
 // build/util.stats.latency/info.js
 var import_react23 = __toESM(require_react());
-function info_default26(R) {
+function info_default27(R) {
   const { defineComponent } = R;
   const InlineView15 = import_react23.default.lazy(async () => Promise.resolve().then(() => (init_inline_view11(), inline_view_exports11)));
   const SourceNodeSelection2 = import_react23.default.lazy(async () => Promise.resolve().then(() => (init_source_node_selection(), source_node_selection_exports)));
@@ -22961,6 +22953,7 @@ AllComponents.push((r) => info_default23(r));
 AllComponents.push((r) => info_default24(r));
 AllComponents.push((r) => info_default25(r));
 AllComponents.push((r) => info_default26(r));
+AllComponents.push((r) => info_default27(r));
 export {
   getNodeInfo as default
 };