@norskvideo/norsk-studio-source-switcher 1.9.0-2025-01-27-b21c8c91

package/lib/runtime.js

@@ -0,0 +1,637 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceSwitch = void 0;
+const norsk_sdk_1 = require("@norskvideo/norsk-sdk");
+const runtime_1 = require("@norskvideo/norsk-studio-built-ins/lib/input.silence/runtime");
+const base_nodes_1 = require("@norskvideo/norsk-studio/lib/extension/base-nodes");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const util_1 = require("@norskvideo/norsk-studio/lib/shared/util");
+const logging_1 = require("@norskvideo/norsk-studio/lib/server/logging");
+const config_1 = require("@norskvideo/norsk-studio/lib/shared/config");
+const webrtcSettings_1 = require("@norskvideo/norsk-studio-built-ins/lib/shared/webrtcSettings");
+const json_refs_1 = require("json-refs");
+class SourceSwitchDefinition {
+    async create(norsk, cfg, cb, runtime) {
+        const updates = runtime.updates;
+        const onActiveSourceChanged = (source, overlays) => {
+            updates.raiseEvent({ type: 'active-source-changed', activeSource: source, overlays });
+        };
+        const onSourceOnline = (source) => {
+            updates.raiseEvent({ type: 'source-online', source });
+        };
+        const onPlayerOnline = ({ source, url }) => {
+            updates.raiseEvent({ type: 'player-online', source, url });
+        };
+        const onSourceOffline = (source) => {
+            updates.raiseEvent({ type: 'source-offline', source });
+        };
+        const onSourcesDiscovered = (sources) => {
+            updates.raiseEvent({ type: 'sources-discovered', sources });
+        };
+        const cfgWithHooks = { onActiveSourceChanged, onSourcesDiscovered, onSourceOnline, onSourceOffline, onPlayerOnline, ...cfg };
+        const node = new SourceSwitch(norsk, cfgWithHooks, runtime);
+        await node.initialised;
+        if (node.whepPreview?.endpointUrl)
+            updates.raiseEvent({ type: 'preview-player-online', url: node.whepPreview?.endpointUrl });
+        cb(node);
+    }
+    handleCommand(node, command) {
+        const commandType = command.type;
+        switch (commandType) {
+            case 'select-source':
+                node.setActiveSource(command.source, command.overlays);
+                break;
+            default:
+                (0, util_1.assertUnreachable)(commandType);
+        }
+    }
+    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);
+        return [
+            {
+                url: '/status',
+                method: 'GET',
+                handler: ({ runtime: { updates } }) => ((_req, res) => {
+                    const { availableSources, activeOverlays, activeSource } = updates.latest();
+                    const value = {
+                        available: availableSources.map((f) => ({
+                            source: sourceSwitchSourceToPin(f),
+                            resolution: f.resolution,
+                            frameRate: f.frameRate,
+                            age: (new Date().valueOf() - f.wentLiveAt) / 1000.0
+                        })),
+                        active: {
+                            primary: sourceSwitchSourceToPin(activeSource),
+                            overlays: activeOverlays.map((o) => ({
+                                sourceRect: o.sourceRect,
+                                destRect: o.destRect,
+                                source: sourceSwitchSourceToPin(o.source)
+                            }))
+                        }
+                    };
+                    res.json(value);
+                }),
+                responses: {
+                    '200': {
+                        description: "Information about the presently active source and any configured overlays",
+                        content: {
+                            "application/json": {
+                                schema: resolved.components.schemas['status']
+                            },
+                        }
+                    }
+                }
+            },
+            {
+                url: '/active',
+                method: 'POST',
+                handler: ({ runtime: { updates } }) => ((req, res) => {
+                    const update = req.body;
+                    const primary = update.primary;
+                    if (!primary) {
+                        res.status(400).send(`Source ${primary} does not exist`);
+                        return;
+                    }
+                    const latest = updates.latest();
+                    const converted = pinToSourceSwitchSource(primary);
+                    const exists = latest.availableSources.find((s) => s.id == converted.id && s.key == converted.key);
+                    const overlays = update.overlays?.map((o) => {
+                        const convertedSource = pinToSourceSwitchSource(o.source);
+                        return {
+                            source: convertedSource,
+                            sourceRect: o.sourceRect,
+                            destRect: o.destRect,
+                        };
+                    });
+                    if (!exists) {
+                        res.status(400).send("source isn't active or doesn't exist");
+                        return;
+                    }
+                    if (overlays?.reduce((a, o) => {
+                        if (a)
+                            return a;
+                        const exists = latest.availableSources.find((s) => s.id == o.source.id && s.key == o.source.key);
+                        if (!exists) {
+                            res.status(400).send(`overlay ${sourceSwitchSourceToPin(o.source)} isn't active or doesn't exist`);
+                        }
+                        return !exists;
+                    }, false))
+                        return;
+                    if (typeof update.transition?.durationMs === 'number') {
+                        if (update.transition.durationMs > 10000.0) {
+                            res.status(400).send("fadeMs too large");
+                            return;
+                        }
+                    }
+                    else {
+                        if (update.transition)
+                            update.transition.durationMs = 0;
+                    }
+                    updates.sendCommand({
+                        type: 'select-source',
+                        source: converted,
+                        overlays: overlays ?? []
+                    });
+                    res.send("ok");
+                }),
+                requestBody: {
+                    description: "The new primary source and any overlays required on it",
+                    content: {
+                        "application/json": {
+                            schema: resolved.components.schemas['status-update']
+                        },
+                    }
+                },
+                responses: {
+                    '204': {
+                        description: "The update was requested successfully, and will be applied in due course"
+                    },
+                    '400': {
+                        description: "There was a problem with the request"
+                    }
+                }
+            }
+        ];
+    }
+}
+exports.default = SourceSwitchDefinition;
+class SourceSwitch extends base_nodes_1.CustomAutoDuplexNode {
+    norsk;
+    cfg;
+    audio;
+    video;
+    smooth;
+    initialised;
+    activeSource = { pin: '', primary: { id: '' }, overlays: [] };
+    desiredSource = this.activeSource;
+    pendingSource = this.activeSource;
+    availableSources = [];
+    lastSmoothSwitchContext = new Map();
+    streamsOnline = new Set();
+    whepOutputs = new Map();
+    encodePreview;
+    whepPreview;
+    subscriptions = [];
+    overlayInputs = [];
+    updates;
+    shared;
+    composeCount = 0;
+    pendingCompose;
+    activeCompose;
+    async initialise() {
+        const audio = await runtime_1.SilenceSource.create(this.norsk, {
+            id: `${this.cfg.id}-audio-silence`,
+            displayName: `${this.cfg.id}-audio-silence`,
+            channelLayout: this.cfg.channelLayout,
+            sampleRate: this.cfg.sampleRate,
+        });
+        const video = await this.norsk.input.videoTestCard({
+            id: `${this.cfg.id}-video-card`,
+            sourceName: 'video-card',
+            resolution: this.cfg.resolution,
+            frameRate: this.cfg.frameRate,
+            pattern: 'black',
+        });
+        const smooth = await this.norsk.processor.control.streamSwitchSmooth({
+            id: `${this.cfg.id}-switch`,
+            outputSource: "output",
+            activeSource: "fallback",
+            outputResolution: this.cfg.resolution,
+            frameRate: this.cfg.frameRate,
+            alignment: "aligned",
+            sampleRate: this.cfg.sampleRate,
+            channelLayout: this.cfg.channelLayout,
+            onInboundContextChange: this.onSwitchContext.bind(this),
+            onTransitionComplete: this.onTransitionComplete.bind(this),
+            hardwareAcceleration: (0, config_1.contractHardwareAcceleration)(this.cfg.__global.hardware, ['quadra', 'nvidia'])
+        });
+        if (this.cfg.enablePreviews) {
+            this.encodePreview = await this.shared.previewEncode({ source: smooth, sourceSelector: norsk_sdk_1.selectVideo }, this.cfg.__global.hardware);
+            this.whepPreview = await this.norsk.output.whep({
+                id: `${this.cfg.id}-preview`,
+                ...(0, webrtcSettings_1.webRtcSettings)(this.cfg.__global.iceServers),
+            });
+            this.whepPreview?.subscribe([{
+                    source: this.encodePreview,
+                    sourceSelector: norsk_sdk_1.selectVideo
+                },
+                {
+                    source: smooth,
+                    sourceSelector: norsk_sdk_1.selectAudio
+                }], norsk_sdk_1.requireAV);
+        }
+        {
+            let prev = 0.0;
+            let lastDiff = 0.0;
+            const debug = await this.norsk.debug.streamTimestampReport({
+                onTimestamp: (_, t) => {
+                    const now = Number((t.n * 100n) / t.d) / 100;
+                    const diff = now - prev;
+                    if (Math.abs(lastDiff - diff) > 0.01) {
+                        (0, logging_1.debuglog)('ABNORMAL AUDIO GAP DETECTED', { gap: now - prev, lastGap: lastDiff });
+                    }
+                    prev = now;
+                    lastDiff = diff;
+                }
+            });
+            debug.subscribe([
+                { source: smooth, sourceSelector: norsk_sdk_1.selectAudio }
+            ]);
+        }
+        {
+            let prev = 0.0;
+            let lastDiff = 0.0;
+            const debug = await this.norsk.debug.streamTimestampReport({
+                onTimestamp: (_, t) => {
+                    const now = Number((t.n * 100n) / t.d) / 100;
+                    const diff = now - prev;
+                    if (Math.abs(lastDiff - diff) > 0.01)
+                        (0, logging_1.debuglog)('ABNORMAL VIDEO GAP DETECTED', { gap: now - prev, lastGap: lastDiff });
+                    prev = now;
+                    lastDiff = diff;
+                }
+            });
+            debug.subscribe([
+                { source: smooth, sourceSelector: norsk_sdk_1.selectVideo }
+            ]);
+        }
+        this.audio = audio;
+        this.video = video;
+        this.smooth = smooth;
+        this.setup({ input: smooth, output: [smooth] });
+        this.subscribe([]);
+    }
+    constructor(norsk, cfg, runtime) {
+        super(cfg.id);
+        this.norsk = norsk;
+        this.cfg = cfg;
+        this.updates = runtime.updates;
+        this.shared = runtime.shared;
+        this.initialised = this.initialise();
+    }
+    onTransitionComplete(pin) {
+        (0, logging_1.debuglog)("Transition complete", { id: this.id, source: this.activeSource, pin });
+        if (pin == this.pendingCompose?.id) {
+            if (this.activeCompose) {
+                void this.activeCompose.compose.close();
+                void this.activeCompose.output.close();
+            }
+            this.activeCompose = this.pendingCompose;
+            this.pendingCompose = undefined;
+            this.doSubscriptions();
+        }
+        else if (this.pendingCompose) {
+            void this.pendingCompose.compose.close();
+            void this.pendingCompose.output.close();
+            this.pendingCompose = undefined;
+        }
+        this.activeSource = this.desiredSource;
+        this.cfg.onActiveSourceChanged?.(this.activeSource.primary, this.activeSource.overlays);
+    }
+    async onSwitchContext(allStreams) {
+        this.lastSmoothSwitchContext = allStreams;
+        await this.maybeSwitchSource();
+    }
+    setActiveSource(source, overlays) {
+        (0, logging_1.debuglog)("Request to switch source registered", { id: this.cfg.id, source });
+        if (!this.sourceIsAvailable(source)) {
+            (0, logging_1.warninglog)("Request to switch source ignored because it doesn't exist", { id: this.cfg.id, source, available: this.availableSources });
+            return;
+        }
+        if (this.pendingCompose)
+            return;
+        if (this.desiredSource != this.activeSource)
+            return;
+        if (overlays.length > 0) {
+            void this.setupComposeSource(source, overlays);
+        }
+        else {
+            this.desiredSource = { pin: sourceSwitchSourceToPin(source), primary: source, overlays: [] };
+            void this.maybeSwitchSource();
+        }
+    }
+    async maybeSwitchToFallback(source) {
+        if (this.pendingSource.primary.id == "fallback")
+            return;
+        const allStreams = this.lastSmoothSwitchContext;
+        const currentUnavailable = !this.sourceIsAvailable(source.primary) || allStreams.get(sourceSwitchSourceToPin(source.primary))?.length !== 2;
+        const fallbackAvailable = this.sourceIsAvailable({ id: 'fallback' }) && allStreams.get(sourceSwitchSourceToPin({ id: 'fallback' }))?.length == 2;
+        if (currentUnavailable && fallbackAvailable) {
+            (0, logging_1.debuglog)("Switching to fallback source", { id: this.id });
+            this.desiredSource = { pin: 'fallback', primary: { id: 'fallback' }, overlays: [] };
+            this.pendingSource = this.desiredSource;
+            await this.smooth?.switchSource("fallback");
+        }
+    }
+    async maybeSwitchSource() {
+        const oldSources = this.availableSources;
+        const allStreams = this.lastSmoothSwitchContext;
+        this.availableSources = [...allStreams.keys()].map(pinToSourceSwitchSource);
+        if (this.pendingSource !== this.desiredSource) {
+            const currentAvailable = this.sourceIsAvailable(this.desiredSource.primary) && allStreams.get(this.desiredSource.pin)?.length == 2;
+            if (currentAvailable) {
+                this.pendingSource = this.desiredSource;
+                await this.smooth?.switchSource(this.desiredSource.pin);
+            }
+        }
+        else if (this.pendingSource != this.activeSource) {
+            await this.maybeSwitchToFallback(this.pendingSource);
+        }
+        else {
+            await this.maybeSwitchToFallback(this.activeSource);
+        }
+        for (const existing of oldSources) {
+            if (existing.id == this.pendingCompose?.id)
+                continue;
+            if (existing.id == this.activeCompose?.id)
+                continue;
+            const pin = sourceSwitchSourceToPin(existing);
+            if (!this.sourceIsAvailable(existing) || allStreams.get(pin)?.length == 0) {
+                if (this.streamsOnline.has(pin)) {
+                    (0, logging_1.debuglog)("Source offline", { id: this.id, source: existing });
+                    this.streamsOnline.delete(pin);
+                    this.cfg?.onSourceOffline(existing);
+                }
+                const player = this.whepOutputs.get(pin);
+                if (player) {
+                    this.whepOutputs.delete(pin);
+                    await player.whep.close();
+                }
+            }
+        }
+        for (const current of this.availableSources) {
+            if (current.id == this.pendingCompose?.id)
+                continue;
+            if (current.id == this.activeCompose?.id)
+                continue;
+            const pin = sourceSwitchSourceToPin(current);
+            if (!this.streamsOnline.has(pin) && allStreams.get(pin)?.length == 2) {
+                (0, logging_1.debuglog)("Source online", { id: this.id, source: current });
+                const streams = allStreams.get(pin);
+                const video = streams?.find((f) => f.message.case == "video");
+                if (video && video.message.case == "video") {
+                    this.streamsOnline.add(pin);
+                    this.cfg?.onSourceOnline({
+                        resolution: {
+                            width: video.message.value.width,
+                            height: video.message.value.height
+                        },
+                        frameRate: video.message.value.frameRate,
+                        wentLiveAt: new Date().valueOf(),
+                        ...current
+                    });
+                    if (this.cfg.enablePreviews && !this.whepOutputs.get(pin)) {
+                        const whep = await this.norsk.output.whep({
+                            id: `${this.id}-whep-${pin}`,
+                            ...(0, webrtcSettings_1.webRtcSettings)(this.cfg.__global.iceServers),
+                        });
+                        this.whepOutputs.set(pin, { whep });
+                        this.cfg?.onPlayerOnline({ source: current, url: whep.endpointUrl });
+                    }
+                }
+            }
+        }
+        void this.setupPreviewPlayers();
+    }
+    async setupComposeSource(source, overlays) {
+        if (this.pendingCompose) {
+            await this.pendingCompose.compose.close();
+            await this.pendingCompose.output.close();
+            this.pendingCompose = undefined;
+        }
+        const id = `${this.id}-compose-${this.composeCount++}`;
+        this.pendingCompose = {
+            id,
+            compose: await this.norsk.processor.transform.videoCompose({
+                id,
+                outputResolution: this.cfg.resolution,
+                referenceStream: 'background',
+                missingStreamBehaviour: 'drop_part',
+                parts: [
+                    {
+                        pin: "background",
+                        compose: norsk_sdk_1.VideoComposeDefaults.fullscreen(),
+                        opacity: 1.0,
+                        zIndex: 0
+                    },
+                    ...overlays.map((o, i) => ({
+                        pin: `overlay-${i}`,
+                        opacity: 1.0,
+                        zIndex: i + 1,
+                        compose: (metadata, settings) => ({
+                            sourceRect: o.sourceRect ?? { x: 0, y: 0, width: metadata.width, height: metadata.height },
+                            destRect: o.destRect ?? { x: 0, y: 0, width: settings.outputResolution.width, height: settings.outputResolution.height }
+                        })
+                    }))
+                ]
+            }),
+            output: await this.norsk.processor.transform.streamKeyOverride({
+                id: `${id}-video`,
+                streamKey: {
+                    streamId: 256,
+                    programNumber: 1,
+                    sourceName: id,
+                    renditionName: 'default'
+                }
+            }),
+            audio: await this.norsk.processor.transform.streamKeyOverride({
+                id: `${id}-audio`,
+                streamKey: {
+                    streamId: 257,
+                    programNumber: 1,
+                    sourceName: id,
+                    renditionName: 'default'
+                }
+            })
+        };
+        const background = this.subscriptions.find((s) => s.source.id == source.id);
+        if (!background) {
+            (0, logging_1.warninglog)("Unable to find source for stream", { source });
+            await this.pendingCompose.compose.close();
+            await this.pendingCompose.output.close();
+            this.pendingCompose = undefined;
+            return;
+        }
+        this.pendingCompose.output.subscribe([
+            { source: this.pendingCompose.compose, sourceSelector: norsk_sdk_1.selectVideo }
+        ]);
+        await this.ensureEnoughOverlaysExist(overlays);
+        overlays.forEach((o, i) => {
+            const source = this.subscriptions.find((s) => s.source.id == o.source.id);
+            if (!source) {
+                this.overlayInputs[i].subscribe([]);
+                return;
+            }
+            this.overlayInputs[i].subscribe(o.source.key ?
+                [source.selectVideoForKey(o.source.key)[0]] :
+                [source.selectVideo()[0]]);
+        });
+        this.pendingCompose.compose.subscribeToPins([
+            source.key ?
+                background.selectVideoToPinForKey("background", source.key)[0] :
+                background.selectVideoToPin("background")[0],
+            ...overlays.map((_o, i) => {
+                return {
+                    source: this.overlayInputs[i],
+                    sourceSelector: (0, norsk_sdk_1.videoToPin)(`overlay-${i}`)
+                };
+            })
+        ]);
+        this.pendingCompose.audio.subscribe([
+            source.key ?
+                background.selectAudioForKey(source.key)[0] :
+                background.selectAudio()[0]
+        ]);
+        this.desiredSource = {
+            pin: `${this.pendingCompose.id}`, overlays, primary: source
+        };
+        this.doSubscriptions();
+    }
+    async ensureEnoughOverlaysExist(overlays) {
+        while (this.overlayInputs.length < overlays.length) {
+            const i = await this.norsk.processor.transform.streamKeyOverride({
+                id: `${this.id}-compose-input-${this.overlayInputs.length}`,
+                streamKey: {
+                    programNumber: 1,
+                    streamId: 256,
+                    sourceName: "compose-input",
+                    renditionName: `input-${this.overlayInputs.length}`
+                }
+            });
+            this.overlayInputs.push(i);
+        }
+    }
+    sourceIsAvailable(source) {
+        return !!this.availableSources.find((s) => s.id == source.id && s.key == source.key);
+    }
+    subscribe(subs, opts) {
+        this.subscriptions = subs;
+        this.doSubscriptions(opts);
+        void this.setupPreviewPlayers();
+    }
+    doSubscriptions(opts) {
+        const knownSources = [];
+        const subs = this.subscriptions;
+        const subscriptions = subs.flatMap((s) => {
+            const sType = s.streams.type;
+            switch (sType) {
+                case 'take-all-streams':
+                    return s.activeSourceKeys().flatMap((key) => {
+                        knownSources.push({ id: s.source.id });
+                        return s.selectAvToPinForKey(pinName(s.source.id, key), key);
+                    });
+                case 'take-first-stream':
+                    knownSources.push({ id: s.source.id });
+                    return s.selectAvToPin(pinName(s.source.id));
+                case 'take-specific-stream':
+                    knownSources.push({ id: s.source.id });
+                    return s.selectAvToPin((pinName(s.source.id)));
+                case 'take-specific-streams':
+                    return s.activeSourceKeys().flatMap((key) => {
+                        knownSources.push({ id: s.source.id, key });
+                        return s.selectAvToPinForKey(pinName(s.source.id, key), key);
+                    });
+                default:
+                    (0, util_1.assertUnreachable)(sType);
+            }
+        }).filter((x) => !!x) ?? [];
+        if (this.audio)
+            subscriptions.push({ source: (this.audio.relatedMediaNodes.output[0]), sourceSelector: (0, norsk_sdk_1.audioToPin)("fallback") });
+        if (this.video) {
+            subscriptions.push({ source: this.video, sourceSelector: (0, norsk_sdk_1.videoToPin)("fallback") });
+            knownSources.push({ id: "fallback" });
+        }
+        this.cfg.onSourcesDiscovered(knownSources);
+        if (this.pendingCompose) {
+            subscriptions.push({
+                source: this.pendingCompose.output,
+                sourceSelector: (0, norsk_sdk_1.videoToPin)(`${this.pendingCompose.id}`)
+            });
+            subscriptions.push({
+                source: this.pendingCompose.audio,
+                sourceSelector: (0, norsk_sdk_1.audioToPin)(`${this.pendingCompose.id}`)
+            });
+        }
+        if (this.activeCompose) {
+            subscriptions.push({
+                source: this.activeCompose.output,
+                sourceSelector: (0, norsk_sdk_1.videoToPin)(`${this.activeCompose.id}`)
+            });
+            subscriptions.push({
+                source: this.activeCompose.audio,
+                sourceSelector: (0, norsk_sdk_1.audioToPin)(`${this.activeCompose.id}`)
+            });
+        }
+        (0, logging_1.debuglog)("Subcription complete, known sources", { id: this.id, knownSources });
+        this.smooth?.subscribeToPins(subscriptions, opts?.requireOneOfEverything ? (ctx) => ctx.streams.length == (subs.length * 2) + 2 : undefined);
+    }
+    async setupPreviewPlayers() {
+        if (!this.cfg.enablePreviews) {
+            return;
+        }
+        for (const [active, player] of this.whepOutputs) {
+            const [id, key] = pinToSourceAndKey(active);
+            const source = this.subscriptions.find((s) => s.source.id == id);
+            if (!player)
+                continue;
+            if (active === "fallback") {
+                const subscriptions = [];
+                if (this.audio)
+                    subscriptions.push({ source: (this.audio.relatedMediaNodes.output[0]), sourceSelector: norsk_sdk_1.selectAudio });
+                if (this.video) {
+                    if (!player.encoder) {
+                        player.encoder = await this.shared.previewEncode({ source: this.video, sourceSelector: norsk_sdk_1.selectVideo }, this.cfg.__global.hardware);
+                    }
+                    subscriptions.push({ source: player.encoder, sourceSelector: norsk_sdk_1.selectVideo });
+                }
+                player.whep.subscribe(subscriptions);
+            }
+            else {
+                if (!source)
+                    continue;
+                if (!player.encoder) {
+                    player.encoder = await this.shared.previewEncode(key ? source.selectVideoForKey(key)[0] : source.selectVideo()[0], this.cfg.__global.hardware);
+                }
+                player.whep.subscribe((key ? source.selectAudioForKey(key) : source.selectAudio()).concat([
+                    { source: player.encoder, sourceSelector: norsk_sdk_1.selectVideo }
+                ]));
+            }
+        }
+    }
+    async close() {
+        await super.close();
+        await this.audio?.close();
+        await this.video?.close();
+    }
+}
+exports.SourceSwitch = SourceSwitch;
+function pinName(sourceId, key) {
+    if (key) {
+        return `${sourceId}__${key}`;
+    }
+    else {
+        return sourceId;
+    }
+}
+function pinToSourceAndKey(pin) {
+    if (pin.indexOf('__') >= 0) {
+        const result = pin.split('__', 2);
+        return [result[0], result[1]];
+    }
+    return [pin, undefined];
+}
+function pinToSourceSwitchSource(pin) {
+    const [id, key] = pinToSourceAndKey(pin);
+    return { id, key };
+}
+function sourceSwitchSourceToPin(source) {
+    return pinName(source.id, source.key);
+}
+//# sourceMappingURL=runtime.js.map