@eluvio/elv-client-js 4.0.114 → 4.0.115

package/dist/src/client/LiveStream.js

@@ -0,0 +1,2640 @@
+var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");
+var _defineProperty = require("@babel/runtime/helpers/defineProperty");
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+var _this = this;
+/* eslint no-console: 0 */
+
+/**
+ * Methods for Live Stream creation and management
+ *
+ * @module ElvClient/LiveStream
+ */
+
+var _require = require("./LiveConf"),
+  LiveConf = _require.LiveConf;
+var path = require("path");
+var fs = require("fs");
+var HttpClient = require("../HttpClient");
+var Fraction = require("fraction.js");
+var _require2 = require("../Validation"),
+  ValidateObject = _require2.ValidateObject,
+  ValidatePresence = _require2.ValidatePresence;
+var ContentObjectAudit = require("../ContentObjectAudit");
+var MakeTxLessToken = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var client, libraryId, objectId, versionHash, tok;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          client = _ref.client, libraryId = _ref.libraryId, objectId = _ref.objectId, versionHash = _ref.versionHash;
+          _context.next = 3;
+          return client.authClient.AuthorizationToken({
+            libraryId: libraryId,
+            objectId: objectId,
+            versionHash: versionHash,
+            channelAuth: false,
+            noCache: true,
+            noAuth: true
+          });
+        case 3:
+          tok = _context.sent;
+          return _context.abrupt("return", tok);
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function MakeTxLessToken(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var Sleep = function Sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+};
+var CueInfo = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+    var eventId, status, cues, lroStatusResponse, eventStart, eventEnd, _i, _Object$values, value, _i2, _Object$values2, event;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          eventId = _ref3.eventId, status = _ref3.status;
+          _context2.prev = 1;
+          _context2.t0 = _this.utils;
+          _context2.next = 5;
+          return HttpClient.Fetch(status.lro_status_url);
+        case 5:
+          _context2.t1 = _context2.sent;
+          _context2.next = 8;
+          return _context2.t0.ResponseToJson.call(_context2.t0, _context2.t1);
+        case 8:
+          lroStatusResponse = _context2.sent;
+          console.log("lroStatusResponse", lroStatusResponse);
+          cues = lroStatusResponse.custom.cues;
+          _context2.next = 17;
+          break;
+        case 13:
+          _context2.prev = 13;
+          _context2.t2 = _context2["catch"](1);
+          console.log("LRO status failed", _context2.t2);
+          return _context2.abrupt("return", {
+            error: "failed to retrieve status",
+            eventId: eventId
+          });
+        case 17:
+          _i = 0, _Object$values = Object.values(cues);
+        case 18:
+          if (!(_i < _Object$values.length)) {
+            _context2.next = 37;
+            break;
+          }
+          value = _Object$values[_i];
+          _i2 = 0, _Object$values2 = Object.values(value.descriptors);
+        case 21:
+          if (!(_i2 < _Object$values2.length)) {
+            _context2.next = 34;
+            break;
+          }
+          event = _Object$values2[_i2];
+          if (!(event.id == eventId)) {
+            _context2.next = 31;
+            break;
+          }
+          _context2.t3 = event.type_id;
+          _context2.next = _context2.t3 === 32 ? 27 : _context2.t3 === 16 ? 27 : _context2.t3 === 33 ? 29 : _context2.t3 === 17 ? 29 : 31;
+          break;
+        case 27:
+          eventStart = value.insertion_time;
+          return _context2.abrupt("break", 31);
+        case 29:
+          eventEnd = value.insertion_time;
+          return _context2.abrupt("break", 31);
+        case 31:
+          _i2++;
+          _context2.next = 21;
+          break;
+        case 34:
+          _i++;
+          _context2.next = 18;
+          break;
+        case 37:
+          return _context2.abrupt("return", {
+            eventStart: eventStart,
+            eventEnd: eventEnd,
+            eventId: eventId
+          });
+        case 38:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[1, 13]]);
+  }));
+  return function CueInfo(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+/**
+ * Set the offering for the live stream
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {Object} client - The client object
+ * @param {string} libraryId - ID of the library for the new live stream object
+ * @param {string} objectId - ID of the new live stream object
+ * @param {string=} typeAbrMaster - Content type hash
+ * @param {string=} typeLiveStream - Content type hash
+ * @param {string} streamUrl - Live source URL
+ * @param {object} abrProfile - ABR Profile for the offering
+ * @param {number} aBitRate - Audio bitrate
+ * @param {number} aChannels - Audio channels
+ * @param {number} aSampleRate - Audio sample rate
+ * @param {number} aStreamIndex - Audio stream index
+ * @param {string} aTimeBase - Audio time base as a fraction, e.g. "1/48000" (usually equal to 1/aSampleRate)
+ * @param {string} aChannelLayout - Channel layout, e.g. "stereo"
+ * @param {number} vBitRate - Video bitrate
+ * @param {number} vHeight - Video height
+ * @param {number} vStreamIndex - Video stream index
+ * @param {number} vWidth - Video width
+ * @param {string} vDisplayAspectRatio - Display aspect ratio as a fraction, e.g. "16/9"
+ * @param {string} vFrameRate - Frame rate as an integer, e.g. "30"
+ * @param {string} vTimeBase - Time base as a fraction, e.g. "1/30000"
+ *
+ * @return {Promise<string>} - Final hash of the live stream object
+ */
+var StreamGenerateOffering = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
+    var client, libraryId, objectId, typeAbrMaster, typeLiveStream, streamUrl, abrProfile, aBitRate, aChannels, aSampleRate, aStreamIndex, aTimeBase, aChannelLayout, vBitRate, vHeight, vStreamIndex, vWidth, vDisplayAspectRatio, vFrameRate, vTimeBase, DUMMY_DURATION, aDurationTs, vDurationTs, sourceAudioStream, sourceVideoStream, DUMMY_STREAM, sourceStreams, maxStreamIndex, i, sources, variants, production_master, metadata, editResponse, writeToken, finalizeResponse, masterVersionHash, createResponse, versionHash, finalHash;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          client = _ref5.client, libraryId = _ref5.libraryId, objectId = _ref5.objectId, typeAbrMaster = _ref5.typeAbrMaster, typeLiveStream = _ref5.typeLiveStream, streamUrl = _ref5.streamUrl, abrProfile = _ref5.abrProfile, aBitRate = _ref5.aBitRate, aChannels = _ref5.aChannels, aSampleRate = _ref5.aSampleRate, aStreamIndex = _ref5.aStreamIndex, aTimeBase = _ref5.aTimeBase, aChannelLayout = _ref5.aChannelLayout, vBitRate = _ref5.vBitRate, vHeight = _ref5.vHeight, vStreamIndex = _ref5.vStreamIndex, vWidth = _ref5.vWidth, vDisplayAspectRatio = _ref5.vDisplayAspectRatio, vFrameRate = _ref5.vFrameRate, vTimeBase = _ref5.vTimeBase;
+          // compute duration_ts
+          DUMMY_DURATION = 1001; // should result in integer duration_ts values for both audio and video
+          aDurationTs = Fraction(aTimeBase).inverse().mul(DUMMY_DURATION).valueOf();
+          vDurationTs = Fraction(vTimeBase).inverse().mul(DUMMY_DURATION).valueOf(); // construct /production_master/sources/STREAM_URL/streams
+          sourceAudioStream = {
+            "bit_rate": aBitRate,
+            "channel_layout": aChannelLayout,
+            "channels": aChannels,
+            "codec_name": "aac",
+            "duration": DUMMY_DURATION,
+            "duration_ts": aDurationTs,
+            "frame_count": 0,
+            "language": "",
+            "max_bit_rate": aBitRate,
+            "sample_rate": aSampleRate,
+            "start_pts": 0,
+            "start_time": 0,
+            "time_base": aTimeBase,
+            "type": "StreamAudio"
+          };
+          sourceVideoStream = {
+            "bit_rate": vBitRate,
+            "codec_name": "h264",
+            "display_aspect_ratio": vDisplayAspectRatio,
+            "duration": DUMMY_DURATION,
+            "duration_ts": vDurationTs,
+            "field_order": "progressive",
+            "frame_count": 0,
+            "frame_rate": vFrameRate,
+            "hdr": null,
+            "height": vHeight,
+            "language": "",
+            "max_bit_rate": vBitRate,
+            "sample_aspect_ratio": "1",
+            "start_pts": 0,
+            "start_time": 0,
+            "time_base": vTimeBase,
+            "type": "StreamVideo",
+            "width": vWidth
+          }; // placeholder stream to use if [aStreamIndex, vStreamIndex].sort() is not [0,1]
+          DUMMY_STREAM = {
+            "bit_rate": 0,
+            "codec_name": "",
+            "duration": DUMMY_DURATION,
+            "duration_ts": 2500 * DUMMY_DURATION,
+            "frame_count": 1,
+            "language": "",
+            "max_bit_rate": 0,
+            "start_pts": 0,
+            "start_time": 0,
+            "time_base": "1/2500",
+            "type": "StreamData"
+          };
+          sourceStreams = [];
+          maxStreamIndex = Math.max(aStreamIndex, vStreamIndex);
+          for (i = 0; i <= maxStreamIndex; i++) {
+            if (i === aStreamIndex) {
+              sourceStreams.push(sourceAudioStream);
+            } else if (i === vStreamIndex) {
+              sourceStreams.push(sourceVideoStream);
+            } else {
+              sourceStreams.push(DUMMY_STREAM);
+            }
+          }
+
+          // construct /production_master/sources
+          sources = _defineProperty({}, streamUrl, {
+            "container_format": {
+              "duration": DUMMY_DURATION,
+              "filename": streamUrl,
+              "format_name": "mov,mp4,m4a,3gp,3g2,mj2",
+              "start_time": 0
+            },
+            "streams": sourceStreams
+          }); // construct /production_master/variants
+          variants = {
+            "default": {
+              "streams": {
+                "audio": {
+                  "default_for_media_type": false,
+                  "label": "",
+                  "language": "",
+                  "mapping_info": "",
+                  "sources": [{
+                    "files_api_path": streamUrl,
+                    "stream_index": aStreamIndex
+                  }]
+                },
+                "video": {
+                  "default_for_media_type": false,
+                  "label": "",
+                  "language": "",
+                  "mapping_info": "",
+                  "sources": [{
+                    "files_api_path": streamUrl,
+                    "stream_index": vStreamIndex
+                  }]
+                }
+              }
+            }
+          }; // construct /production_master
+          production_master = {
+            sources: sources,
+            variants: variants
+          }; // get existing metadata
+          console.log("Retrieving current metadata...");
+          _context3.next = 16;
+          return client.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 16:
+          metadata = _context3.sent;
+          // add /production_master to metadata
+          metadata.production_master = production_master;
+
+          // write back to object
+          console.log("Getting write token...");
+          _context3.next = 21;
+          return client.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            options: {
+              type: typeAbrMaster
+            }
+          });
+        case 21:
+          editResponse = _context3.sent;
+          writeToken = editResponse.write_token;
+          console.log("New write token: ".concat(writeToken));
+          console.log("Writing back metadata with /production_master added...");
+          _context3.next = 27;
+          return client.ReplaceMetadata({
+            libraryId: libraryId,
+            metadata: metadata,
+            objectId: objectId,
+            writeToken: writeToken
+          });
+        case 27:
+          console.log("Finalizing...");
+          _context3.next = 30;
+          return client.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken
+          });
+        case 30:
+          finalizeResponse = _context3.sent;
+          masterVersionHash = finalizeResponse.hash;
+          console.log("Finalized, new version hash: ".concat(masterVersionHash));
+
+          // Generate offering
+          _context3.next = 35;
+          return client.CreateABRMezzanine({
+            libraryId: libraryId,
+            objectId: objectId,
+            masterVersionHash: masterVersionHash,
+            variant: "default",
+            offeringKey: "default",
+            abrProfile: abrProfile
+          });
+        case 35:
+          createResponse = _context3.sent;
+          if (createResponse.warnings.length > 0) {
+            console.log("WARNINGS:");
+            console.log(JSON.stringify(createResponse.warnings, null, 2));
+          }
+          if (createResponse.errors.length > 0) {
+            console.log("ERRORS:");
+            console.log(JSON.stringify(createResponse.errors, null, 2));
+          }
+          versionHash = createResponse.hash;
+          console.log("New version hash: ".concat(versionHash));
+
+          // get new metadata
+          console.log("Retrieving revised metadata with offering...");
+          _context3.next = 43;
+          return client.ContentObjectMetadata({
+            libraryId: libraryId,
+            versionHash: versionHash
+          });
+        case 43:
+          metadata = _context3.sent;
+          console.log("Moving /abr_mezzanine/offerings to /offerings and removing /abr_mezzanine...");
+          metadata.offerings = metadata.abr_mezzanine.offerings;
+          delete metadata.abr_mezzanine;
+
+          // add items to media_struct needed to use options.json handler
+          metadata.offerings["default"].media_struct.duration_rat = "".concat(DUMMY_DURATION);
+
+          // write back to object
+          console.log("Getting write token...");
+          _context3.next = 51;
+          return client.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            options: {
+              type: typeLiveStream
+            }
+          });
+        case 51:
+          editResponse = _context3.sent;
+          writeToken = editResponse.write_token;
+          console.log("New write token: ".concat(writeToken));
+          console.log("Writing back metadata with /offerings...");
+          _context3.next = 57;
+          return client.ReplaceMetadata({
+            libraryId: libraryId,
+            metadata: metadata,
+            objectId: objectId,
+            writeToken: writeToken
+          });
+        case 57:
+          console.log("Finalizing...");
+          _context3.next = 60;
+          return client.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken
+          });
+        case 60:
+          finalizeResponse = _context3.sent;
+          finalHash = finalizeResponse.hash;
+          console.log("Finalized, new version hash: ".concat(finalHash));
+          return _context3.abrupt("return", finalHash);
+        case 64:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function StreamGenerateOffering(_x3) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+/**
+ * Retrieve the status of the current live stream session
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {boolean=} stopLro - If specified, will stop LRO
+ * @param {boolean=} showParams - If specified, will return recording_params with status
+ * States:
+ * unconfigured    - no live_recording_config
+ * uninitialized   - no live_recording config generated
+ * inactive        - live_recording config initialized but no 'edge write token'
+ * stopped         - edge-write-token but not started
+ * starting        - LRO running but no source data yet
+ * running         - stream is running and producing output
+ * stalled         - LRO running but no source data (so not producing output)
+ *
+ * @return {Promise<Object>} - The status response for the object, as well as logs, warnings and errors from the master initialization
+ */
+exports.StreamStatus = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref7) {
+    var name, _ref7$stopLro, stopLro, _ref7$showParams, showParams, objectId, status, libraryId, mainMeta, fabURI, edgeWriteToken, edgeMeta, recordings, sequence, period, tlro, videoLastFinalizationTimeEpochSec, videoFinalizedParts, sinceLastFinalize, recording_period, insertions, i, insertionTimeSinceEpoch, state, lroStatus, segDurationMeta, playout_urls, playout_options, hls_clear_enabled, hls_aes128_enabled, hls_sample_aes_enabled, networkInfo, token, embed_net, embed_url;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          name = _ref7.name, _ref7$stopLro = _ref7.stopLro, stopLro = _ref7$stopLro === void 0 ? false : _ref7$stopLro, _ref7$showParams = _ref7.showParams, showParams = _ref7$showParams === void 0 ? false : _ref7$showParams;
+          objectId = name;
+          status = {
+            name: name
+          };
+          _context4.prev = 3;
+          _context4.next = 6;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 6:
+          libraryId = _context4.sent;
+          status.library_id = libraryId;
+          status.object_id = objectId;
+          _context4.next = 11;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            select: ["live_recording_config", "live_recording"]
+          });
+        case 11:
+          mainMeta = _context4.sent;
+          status.reference_url = mainMeta.live_recording_config.reference_url;
+          if (!(mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined)) {
+            _context4.next = 16;
+            break;
+          }
+          status.state = "unconfigured";
+          return _context4.abrupt("return", status);
+        case 16:
+          if (!(mainMeta.live_recording == undefined || mainMeta.live_recording.fabric_config == undefined || mainMeta.live_recording.playout_config == undefined || mainMeta.live_recording.recording_config == undefined)) {
+            _context4.next = 19;
+            break;
+          }
+          status.state = "uninitialized";
+          return _context4.abrupt("return", status);
+        case 19:
+          fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+          if (!(fabURI === undefined)) {
+            _context4.next = 24;
+            break;
+          }
+          console.log("bad fabric config - missing ingress node API");
+          status.state = "uninitialized";
+          return _context4.abrupt("return", status);
+        case 24:
+          // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          status.fabric_api = fabURI;
+          status.url = mainMeta.live_recording.recording_config.recording_params.origin_url;
+          edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          if (edgeWriteToken) {
+            _context4.next = 31;
+            break;
+          }
+          status.state = "inactive";
+          return _context4.abrupt("return", status);
+        case 31:
+          this.RecordWriteToken({
+            writeToken: edgeWriteToken,
+            fabricNodeUrl: fabURI
+          });
+          status.edge_write_token = edgeWriteToken;
+          status.stream_id = edgeWriteToken; // By convention the stream ID is its write token
+          _context4.prev = 34;
+          _context4.next = 37;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            select: ["live_recording"]
+          });
+        case 37:
+          edgeMeta = _context4.sent;
+          _context4.next = 45;
+          break;
+        case 40:
+          _context4.prev = 40;
+          _context4.t0 = _context4["catch"](34);
+          console.error("Unable to read edge write token metadata. Has token been deleted?", _context4.t0);
+          status.state = "inactive";
+          return _context4.abrupt("return", status);
+        case 45:
+          status.edge_meta_size = JSON.stringify(edgeMeta || "").length;
+
+          // If a stream has never been started return state 'inactive'
+          if (!(edgeMeta.live_recording === undefined || edgeMeta.live_recording.recordings === undefined || edgeMeta.live_recording.recordings.recording_sequence === undefined)) {
+            _context4.next = 49;
+            break;
+          }
+          status.state = "stopped";
+          return _context4.abrupt("return", status);
+        case 49:
+          recordings = edgeMeta.live_recording.recordings;
+          status.recording_period_sequence = recordings.recording_sequence;
+          sequence = recordings.recording_sequence;
+          period = recordings.live_offering[sequence - 1];
+          tlro = period.live_recording_handle;
+          status.tlro = tlro;
+          videoLastFinalizationTimeEpochSec = -1;
+          videoFinalizedParts = 0;
+          sinceLastFinalize = -1;
+          if (period.finalized_parts_info && period.finalized_parts_info.video && period.finalized_parts_info.video.last_finalization_time) {
+            videoLastFinalizationTimeEpochSec = period.finalized_parts_info.video.last_finalization_time / 1000000;
+            videoFinalizedParts = period.finalized_parts_info.video.n_parts;
+            sinceLastFinalize = Math.floor(new Date().getTime() / 1000) - videoLastFinalizationTimeEpochSec;
+          }
+          recording_period = {
+            activation_time_epoch_sec: period.recording_start_time_epoch_sec,
+            start_time_epoch_sec: period.start_time_epoch_sec,
+            start_time_text: new Date(period.start_time_epoch_sec * 1000).toLocaleString(),
+            end_time_epoch_sec: period.end_time_epoch_sec,
+            end_time_text: period.end_time_epoch_sec === 0 ? null : new Date(period.end_time_epoch_sec * 1000).toLocaleString(),
+            video_parts: videoFinalizedParts,
+            video_last_part_finalized_epoch_sec: videoLastFinalizationTimeEpochSec,
+            video_since_last_finalize_sec: sinceLastFinalize
+          };
+          status.recording_period = recording_period;
+          _context4.next = 63;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            call: "live/status/" + tlro
+          });
+        case 63:
+          status.lro_status_url = _context4.sent;
+          status.insertions = [];
+          if (edgeMeta.live_recording.playout_config.interleaves != undefined && edgeMeta.live_recording.playout_config.interleaves[sequence] != undefined) {
+            insertions = edgeMeta.live_recording.playout_config.interleaves[sequence];
+            for (i = 0; i < insertions.length; i++) {
+              insertionTimeSinceEpoch = recording_period.start_time_epoch_sec + insertions[i].insertion_time;
+              status.insertions[i] = {
+                insertion_time_since_start: insertions[i].insertion_time,
+                insertion_time: new Date(insertionTimeSinceEpoch * 1000).toISOString(),
+                insertion_time_local: new Date(insertionTimeSinceEpoch * 1000).toLocaleString(),
+                target: insertions[i].playout
+              };
+            }
+          }
+          if (showParams) {
+            status.recording_params = edgeMeta.live_recording.recording_config.recording_params;
+          }
+          state = "stopped";
+          lroStatus = "";
+          _context4.prev = 69;
+          _context4.t1 = this.utils;
+          _context4.next = 73;
+          return HttpClient.Fetch(status.lro_status_url);
+        case 73:
+          _context4.t2 = _context4.sent;
+          _context4.next = 76;
+          return _context4.t1.ResponseToJson.call(_context4.t1, _context4.t2);
+        case 76:
+          lroStatus = _context4.sent;
+          state = lroStatus.state;
+          status.warnings = lroStatus.custom && lroStatus.custom.warnings;
+          status.quality = lroStatus.custom && lroStatus.custom.quality;
+          if (lroStatus.custom && lroStatus.custom.status) {
+            status.recording_status = lroStatus.custom.status;
+          }
+          _context4.next = 89;
+          break;
+        case 83:
+          _context4.prev = 83;
+          _context4.t3 = _context4["catch"](69);
+          console.log("LRO Status (failed): ", _context4.t3.response.statusCode);
+          status.state = "stopped";
+          status.error = _context4.t3.response;
+          return _context4.abrupt("return", status);
+        case 89:
+          segDurationMeta = edgeMeta.live_recording.recording_config.recording_params.xc_params.seg_duration; // Convert LRO 'state' to desired 'state'
+          if (state === "running" && videoLastFinalizationTimeEpochSec <= 0) {
+            state = "starting";
+          } else if (state === "running" && segDurationMeta !== undefined && sinceLastFinalize > parseInt(segDurationMeta) + 5) {
+            state = "stalled";
+          } else if (state == "terminated") {
+            state = "stopped";
+          }
+          status.state = state;
+          if (!((state === "running" || state === "stalled" || state === "starting") && stopLro)) {
+            _context4.next = 111;
+            break;
+          }
+          _context4.next = 95;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            call: "live/stop/" + tlro
+          });
+        case 95:
+          lroStopUrl = _context4.sent;
+          _context4.prev = 96;
+          _context4.t4 = this.utils;
+          _context4.next = 100;
+          return HttpClient.Fetch(lroStopUrl);
+        case 100:
+          _context4.t5 = _context4.sent;
+          _context4.next = 103;
+          return _context4.t4.ResponseToJson.call(_context4.t4, _context4.t5);
+        case 103:
+          console.log("LRO Stop: ", lroStatus.body);
+          _context4.next = 109;
+          break;
+        case 106:
+          _context4.prev = 106;
+          _context4.t6 = _context4["catch"](96);
+          console.log("LRO Stop (failed): ", _context4.t6.response.statusCode);
+        case 109:
+          state = "stopped";
+          status.state = state;
+        case 111:
+          if (!(state === "running")) {
+            _context4.next = 142;
+            break;
+          }
+          playout_urls = {};
+          _context4.next = 115;
+          return this.PlayoutOptions({
+            objectId: objectId,
+            linkPath: "public/asset_metadata/sources/default"
+          });
+        case 115:
+          playout_options = _context4.sent;
+          hls_clear_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods.clear !== undefined;
+          if (!hls_clear_enabled) {
+            _context4.next = 121;
+            break;
+          }
+          _context4.next = 120;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-clear/playlist.m3u8"
+          });
+        case 120:
+          playout_urls.hls_clear = _context4.sent;
+        case 121:
+          hls_aes128_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["aes-128"] !== undefined;
+          if (!hls_aes128_enabled) {
+            _context4.next = 126;
+            break;
+          }
+          _context4.next = 125;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-aes128/playlist.m3u8"
+          });
+        case 125:
+          playout_urls.hls_aes128 = _context4.sent;
+        case 126:
+          hls_sample_aes_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["sample-aes"] !== undefined;
+          if (!hls_sample_aes_enabled) {
+            _context4.next = 131;
+            break;
+          }
+          _context4.next = 130;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-sample-aes/playlist.m3u8"
+          });
+        case 130:
+          playout_urls.hls_sample_aes = _context4.sent;
+        case 131:
+          _context4.next = 133;
+          return this.NetworkInfo();
+        case 133:
+          networkInfo = _context4.sent;
+          _context4.next = 136;
+          return this.authClient.AuthorizationToken({
+            libraryId: libraryId,
+            objectId: objectId,
+            channelAuth: false,
+            noCache: true,
+            noAuth: true
+          });
+        case 136:
+          token = _context4.sent;
+          embed_net = "main";
+          if (networkInfo.name.includes("demo")) {
+            embed_net = "demo";
+          }
+          embed_url = "https://embed.v3.contentfabric.io/?net=".concat(embed_net, "&p&ct=h&oid=").concat(objectId, "&mt=lv&ath=").concat(token);
+          playout_urls.embed_url = embed_url;
+          status.playout_urls = playout_urls;
+        case 142:
+          _context4.next = 147;
+          break;
+        case 144:
+          _context4.prev = 144;
+          _context4.t7 = _context4["catch"](3);
+          console.error(_context4.t7);
+        case 147:
+          return _context4.abrupt("return", status);
+        case 148:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, this, [[3, 144], [34, 40], [69, 83], [96, 106]]);
+  }));
+  return function (_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+
+/**
+ * Create a new edge write token
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {boolean=} start - If specified, will start the stream after creation
+ *
+ * @return {Promise<Object>} - The status response for the object
+ *
+*/
+exports.StreamCreate = /*#__PURE__*/function () {
+  var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref9) {
+    var name, _ref9$start, start, status, objectId, libraryId, liveRecording, fabURI, response, edgeToken, writeToken, objectHash;
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          name = _ref9.name, _ref9$start = _ref9.start, start = _ref9$start === void 0 ? false : _ref9$start;
+          _context5.next = 3;
+          return this.StreamStatus({
+            name: name
+          });
+        case 3:
+          status = _context5.sent;
+          if (!(status.state != "uninitialized" && status.state !== "inactive" && status.state !== "terminated" && status.state !== "stopped")) {
+            _context5.next = 6;
+            break;
+          }
+          return _context5.abrupt("return", {
+            state: status.state,
+            error: "stream still active - must terminate first"
+          });
+        case 6:
+          objectId = status.object_id;
+          console.log("START: ", name, "start", start);
+          _context5.next = 10;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 10:
+          libraryId = _context5.sent;
+          _context5.next = 13;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            metadataSubtree: "/live_recording"
+          });
+        case 13:
+          liveRecording = _context5.sent;
+          fabURI = liveRecording.fabric_config.ingress_node_api; // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          this.SetNodes({
+            fabricURIs: [fabURI]
+          });
+          console.log("Node URI", fabURI, "ID", liveRecording.fabric_config.ingress_node_id);
+          _context5.next = 20;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 20:
+          response = _context5.sent;
+          edgeToken = response.write_token;
+          console.log("Edge token:", edgeToken);
+
+          /*
+          * Set the metadata, including the edge token.
+          */
+          _context5.next = 25;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 25:
+          response = _context5.sent;
+          writeToken = response.write_token;
+          this.Log("Merging metadata: ", libraryId, objectId, writeToken);
+          _context5.next = 30;
+          return this.MergeMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadata: {
+              live_recording: {
+                status: {
+                  edge_write_token: edgeToken,
+                  state: "active" // indicates there is an active session (set to 'closed' when done)
+                },
+
+                fabric_config: {
+                  edge_write_token: edgeToken
+                }
+              }
+            }
+          });
+        case 30:
+          this.Log("Finalizing content draft: ", libraryId, objectId, writeToken);
+          _context5.next = 33;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Create stream edge write token " + edgeToken
+          });
+        case 33:
+          response = _context5.sent;
+          objectHash = response.hash;
+          this.Log("Finalized object: ", objectHash);
+          status = {
+            object_id: objectId,
+            hash: objectHash,
+            library_id: libraryId,
+            stream_id: edgeToken,
+            edge_write_token: edgeToken,
+            fabric_api: fabURI,
+            state: "stopped"
+          };
+          if (start) {
+            status = this.StreamStartOrStopOrReset({
+              name: name,
+              op: start
+            });
+          }
+          return _context5.abrupt("return", status);
+        case 39:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, this);
+  }));
+  return function (_x5) {
+    return _ref10.apply(this, arguments);
+  };
+}();
+
+/**
+ * Start, stop or reset a stream within the current session (current edge write token)
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {string} op - The operation to perform. Possible values:
+ * 'start'
+ * 'reset' - Stops current LRO recording and starts a new one.  Does
+ * not create a new edge write token (just creates a new recording
+ * period in the existing edge write token)
+ * - 'stop'
+ *
+ * @return {Promise<Object>} - The status response for the stream
+ *
+*/
+exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
+  var _ref12 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref11) {
+    var name, op, status, _tries, tries;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          name = _ref11.name, op = _ref11.op;
+          _context6.prev = 1;
+          _context6.next = 4;
+          return this.StreamStatus({
+            name: name
+          });
+        case 4:
+          status = _context6.sent;
+          if (!(status.state != "stopped")) {
+            _context6.next = 9;
+            break;
+          }
+          if (!(op === "start")) {
+            _context6.next = 9;
+            break;
+          }
+          status.error = "Unable to start stream - state: " + status.state;
+          return _context6.abrupt("return", status);
+        case 9:
+          if (!(status.state == "running" || status.state == "starting" || status.state == "stalled")) {
+            _context6.next = 31;
+            break;
+          }
+          _context6.prev = 10;
+          _context6.next = 13;
+          return this.CallBitcodeMethod({
+            libraryId: status.library_id,
+            objectId: status.object_id,
+            writeToken: status.edge_write_token,
+            method: "/live/stop/" + status.tlro,
+            constant: false
+          });
+        case 13:
+          _context6.next = 17;
+          break;
+        case 15:
+          _context6.prev = 15;
+          _context6.t0 = _context6["catch"](10);
+        case 17:
+          // Wait until LRO is terminated
+          _tries = 10;
+        case 18:
+          if (!(status.state != "stopped" && _tries-- > 0)) {
+            _context6.next = 27;
+            break;
+          }
+          console.log("Wait to terminate - ", status.state);
+          _context6.next = 22;
+          return Sleep(1000);
+        case 22:
+          _context6.next = 24;
+          return this.StreamStatus({
+            name: name
+          });
+        case 24:
+          status = _context6.sent;
+          _context6.next = 18;
+          break;
+        case 27:
+          console.log("Status after stop - ", status.state);
+          if (!(_tries <= 0)) {
+            _context6.next = 31;
+            break;
+          }
+          console.log("Failed to stop");
+          return _context6.abrupt("return", status);
+        case 31:
+          if (!(op === "stop")) {
+            _context6.next = 33;
+            break;
+          }
+          return _context6.abrupt("return", status);
+        case 33:
+          console.log("STARTING", "edge_write_token", status.edge_write_token);
+          _context6.prev = 34;
+          _context6.next = 37;
+          return this.CallBitcodeMethod({
+            libraryId: status.library_id,
+            objectId: status.object_id,
+            writeToken: status.edge_write_token,
+            method: "/live/start",
+            constant: false
+          });
+        case 37:
+          _context6.next = 43;
+          break;
+        case 39:
+          _context6.prev = 39;
+          _context6.t1 = _context6["catch"](34);
+          console.log("LRO Start (failed): ", _context6.t1);
+          return _context6.abrupt("return", {
+            state: status.state,
+            error: "LRO start failed - must create a stream first"
+          });
+        case 43:
+          // Wait until LRO is 'starting'
+          tries = 10;
+        case 44:
+          if (!(status.state != "starting" && tries-- > 0)) {
+            _context6.next = 53;
+            break;
+          }
+          console.log("Wait to start - ", status.state);
+          _context6.next = 48;
+          return Sleep(1000);
+        case 48:
+          _context6.next = 50;
+          return this.StreamStatus({
+            name: name
+          });
+        case 50:
+          status = _context6.sent;
+          _context6.next = 44;
+          break;
+        case 53:
+          console.log("Status after restart - ", status.state);
+          return _context6.abrupt("return", status);
+        case 57:
+          _context6.prev = 57;
+          _context6.t2 = _context6["catch"](1);
+          console.error(_context6.t2);
+        case 60:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6, this, [[1, 57], [10, 15], [34, 39]]);
+  }));
+  return function (_x6) {
+    return _ref12.apply(this, arguments);
+  };
+}();
+
+/**
+ * Close the edge write token and make the stream object inactive.
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ *
+ * @return {Promise<Object>} - The finalize response for the stream object
+ */
+exports.StreamStopSession = /*#__PURE__*/function () {
+  var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_ref13) {
+    var name, objectId, libraryId, mainMeta, fabURI, metaEdgeWriteToken, streamMetadata, status, _yield$this$EditConte, writeToken, newState, stopTime, finalizeMetadata, fin;
+    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          name = _ref13.name;
+          _context7.prev = 1;
+          this.Log("Terminating stream session for: ".concat(name));
+          objectId = name;
+          _context7.next = 6;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 6:
+          libraryId = _context7.sent;
+          _context7.next = 9;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 9:
+          mainMeta = _context7.sent;
+          fabURI = mainMeta.live_recording.fabric_config.ingress_node_api; // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          this.SetNodes({
+            fabricURIs: [fabURI]
+          });
+          metaEdgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          if (metaEdgeWriteToken) {
+            _context7.next = 16;
+            break;
+          }
+          return _context7.abrupt("return", {
+            state: "inactive",
+            error: "The stream is not active"
+          });
+        case 16:
+          _context7.prev = 16;
+          _context7.next = 19;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: metaEdgeWriteToken
+          });
+        case 19:
+          streamMetadata = _context7.sent;
+          _context7.next = 22;
+          return this.StreamStatus({
+            name: name
+          });
+        case 22:
+          status = _context7.sent;
+          if (!(status.state !== "stopped")) {
+            _context7.next = 25;
+            break;
+          }
+          return _context7.abrupt("return", {
+            state: status.state,
+            error: "The stream must be stopped before terminating"
+          });
+        case 25:
+          _context7.next = 27;
+          return this.DeleteWriteToken({
+            libraryId: libraryId,
+            writeToken: metaEdgeWriteToken
+          });
+        case 27:
+          _context7.next = 32;
+          break;
+        case 29:
+          _context7.prev = 29;
+          _context7.t0 = _context7["catch"](16);
+          this.Log("Unable to retrieve metadata for edge write token");
+        case 32:
+          _context7.next = 34;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 34:
+          _yield$this$EditConte = _context7.sent;
+          writeToken = _yield$this$EditConte.writeToken;
+          // Set stop time and inactive state
+          newState = "inactive";
+          stopTime = Math.floor(new Date().getTime() / 1000);
+          finalizeMetadata = {
+            live_recording: {
+              status: {
+                edge_write_token: "",
+                state: newState,
+                recording_stop_time: stopTime
+              },
+              fabric_config: {
+                edge_write_token: ""
+              }
+            }
+          };
+          _context7.next = 41;
+          return this.MergeMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadata: finalizeMetadata
+          });
+        case 41:
+          _context7.next = 43;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Deactivate live stream - stop time ".concat(stopTime)
+          });
+        case 43:
+          fin = _context7.sent;
+          return _context7.abrupt("return", {
+            fin: fin,
+            name: name,
+            state: newState
+          });
+        case 47:
+          _context7.prev = 47;
+          _context7.t1 = _context7["catch"](1);
+          console.error(_context7.t1);
+        case 50:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7, this, [[1, 47], [16, 29]]);
+  }));
+  return function (_x7) {
+    return _ref14.apply(this, arguments);
+  };
+}();
+
+/**
+ * Initialize the stream object
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {boolean=} drm - If specified, playout will be DRM protected
+ * @param {string=} format - Specify the list of playout formats and DRM to support,
+ comma-separated (hls-clear, hls-aes128, hls-sample-aes,
+ hls-fairplay)
+ *
+ * @return {Promise<Object>} - The name, object ID, and state of the stream
+ */
+exports.StreamInitialize = /*#__PURE__*/function () {
+  var _ref16 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(_ref15) {
+    var name, _ref15$drm, drm, format, typeAbrMaster, typeLiveStream, tenantContractId, _yield$this$ContentOb, live_stream, title, res;
+    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          name = _ref15.name, _ref15$drm = _ref15.drm, drm = _ref15$drm === void 0 ? false : _ref15$drm, format = _ref15.format;
+          _context8.next = 3;
+          return this.userProfileClient.TenantContractId();
+        case 3:
+          tenantContractId = _context8.sent;
+          _context8.next = 6;
+          return this.ContentObjectMetadata({
+            libraryId: tenantContractId.replace("iten", "ilib"),
+            objectId: tenantContractId.replace("iten", "iq__"),
+            metadataSubtree: "public/content_types",
+            select: ["live_stream", "title"]
+          });
+        case 6:
+          _yield$this$ContentOb = _context8.sent;
+          live_stream = _yield$this$ContentOb.live_stream;
+          title = _yield$this$ContentOb.title;
+          if (live_stream) {
+            typeLiveStream = live_stream;
+          }
+          if (title) {
+            typeAbrMaster = title;
+          }
+          if (!(typeAbrMaster === undefined || typeLiveStream === undefined)) {
+            _context8.next = 14;
+            break;
+          }
+          console.log("ERROR - unable to find content types", "ABR Master", typeAbrMaster, "Live Stream", typeLiveStream);
+          return _context8.abrupt("return", {});
+        case 14:
+          _context8.next = 16;
+          return this.StreamSetOfferingAndDRM({
+            name: name,
+            typeAbrMaster: typeAbrMaster,
+            typeLiveStream: typeLiveStream,
+            drm: drm,
+            format: format
+          });
+        case 16:
+          res = _context8.sent;
+          return _context8.abrupt("return", res);
+        case 18:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8, this);
+  }));
+  return function (_x8) {
+    return _ref16.apply(this, arguments);
+  };
+}();
+
+/**
+ * Create a dummy VoD offering and initialize DRM keys.
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {string=} typeAbrMaster - Content type hash
+ * @param {string=} typeLiveStream - Content type hash
+ * @param {boolean=} drm - If specified, DRM will be applied to the stream
+ * @param {string=} format - A list of playout formats and DRM to support, comma-separated
+ * (hls-clear, hls-aes128, hls-sample-aes, hls-fairplay). If specified,
+ * this will take precedence over the drm value
+ *
+ * @return {Promise<Object>} - The name, object ID, and state of the stream
+ */
+exports.StreamSetOfferingAndDRM = /*#__PURE__*/function () {
+  var _ref18 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(_ref17) {
+    var name, typeAbrMaster, typeLiveStream, _ref17$drm, drm, format, status, objectId, aBitRate, aChannels, aSampleRate, aStreamIndex, aTimeBase, aChannelLayout, vBitRate, vHeight, vStreamIndex, vWidth, vDisplayAspectRatio, vFrameRate, vTimeBase, abrProfileDefault, playoutFormats, abrProfile, formats, i, libraryId, mainMeta, fabURI, streamUrl;
+    return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          name = _ref17.name, typeAbrMaster = _ref17.typeAbrMaster, typeLiveStream = _ref17.typeLiveStream, _ref17$drm = _ref17.drm, drm = _ref17$drm === void 0 ? false : _ref17$drm, format = _ref17.format;
+          _context9.next = 3;
+          return this.StreamStatus({
+            name: name
+          });
+        case 3:
+          status = _context9.sent;
+          if (!(status.state != "uninitialized" && status.state != "inactive" && status.state != "stopped")) {
+            _context9.next = 6;
+            break;
+          }
+          return _context9.abrupt("return", {
+            state: status.state,
+            error: "stream still active - must terminate first"
+          });
+        case 6:
+          objectId = status.object_id;
+          console.log("INIT: ", name, objectId);
+          aBitRate = 128000;
+          aChannels = 2;
+          aSampleRate = 48000;
+          aStreamIndex = 1;
+          aTimeBase = "1/48000";
+          aChannelLayout = "stereo";
+          vBitRate = 14000000;
+          vHeight = 720;
+          vStreamIndex = 0;
+          vWidth = 1280;
+          vDisplayAspectRatio = "16/9";
+          vFrameRate = "30000/1001";
+          vTimeBase = "1/30000"; // "1/16000";
+          abrProfileDefault = require("../abr_profiles/abr_profile_live_drm.js");
+          abrProfile = JSON.parse(JSON.stringify(abrProfileDefault));
+          if (!format) {
+            _context9.next = 43;
+            break;
+          }
+          drm = true; // Override DRM parameter
+          playoutFormats = {};
+          formats = format.split(",");
+          i = 0;
+        case 28:
+          if (!(i < formats.length)) {
+            _context9.next = 41;
+            break;
+          }
+          if (!(formats[i] === "hls-clear")) {
+            _context9.next = 33;
+            break;
+          }
+          abrProfile.drm_optional = true;
+          playoutFormats["hls-clear"] = {
+            "drm": null,
+            "protocol": {
+              "type": "ProtoHls"
+            }
+          };
+          return _context9.abrupt("continue", 38);
+        case 33:
+          if (!(formats[i] === "dash-clear")) {
+            _context9.next = 37;
+            break;
+          }
+          abrProfile.drm_optional = true;
+          playoutFormats["dash-clear"] = {
+            "drm": null,
+            "protocol": {
+              "min_buffer_length": 2,
+              "type": "ProtoDash"
+            }
+          };
+          return _context9.abrupt("continue", 38);
+        case 37:
+          playoutFormats[formats[i]] = abrProfile.playout_formats[formats[i]];
+        case 38:
+          i++;
+          _context9.next = 28;
+          break;
+        case 41:
+          _context9.next = 44;
+          break;
+        case 43:
+          if (!drm) {
+            abrProfile.drm_optional = true;
+            playoutFormats = {
+              "hls-clear": {
+                "drm": null,
+                "protocol": {
+                  "type": "ProtoHls"
+                }
+              },
+              "dash-clear": {
+                "drm": null,
+                "protocol": {
+                  "min_buffer_length": 2,
+                  "type": "ProtoDash"
+                }
+              }
+            };
+          } else {
+            playoutFormats = Object.assign({}, abrProfile.playout_formats);
+          }
+        case 44:
+          abrProfile.playout_formats = playoutFormats;
+          _context9.next = 47;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 47:
+          libraryId = _context9.sent;
+          _context9.prev = 48;
+          _context9.next = 51;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 51:
+          mainMeta = _context9.sent;
+          fabURI = mainMeta.live_recording.fabric_config.ingress_node_api; // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          this.SetNodes({
+            fabricURIs: [fabURI]
+          });
+          streamUrl = mainMeta.live_recording.recording_config.recording_params.origin_url;
+          _context9.next = 58;
+          return StreamGenerateOffering({
+            client: this,
+            libraryId: libraryId,
+            objectId: objectId,
+            typeAbrMaster: typeAbrMaster,
+            typeLiveStream: typeLiveStream,
+            streamUrl: streamUrl,
+            abrProfile: abrProfile,
+            aBitRate: aBitRate,
+            aChannels: aChannels,
+            aSampleRate: aSampleRate,
+            aStreamIndex: aStreamIndex,
+            aTimeBase: aTimeBase,
+            aChannelLayout: aChannelLayout,
+            vBitRate: vBitRate,
+            vHeight: vHeight,
+            vStreamIndex: vStreamIndex,
+            vWidth: vWidth,
+            vDisplayAspectRatio: vDisplayAspectRatio,
+            vFrameRate: vFrameRate,
+            vTimeBase: vTimeBase
+          });
+        case 58:
+          console.log("Finished generating offering");
+          return _context9.abrupt("return", {
+            name: name,
+            object_id: objectId,
+            state: "initialized"
+          });
+        case 62:
+          _context9.prev = 62;
+          _context9.t0 = _context9["catch"](48);
+          console.error(_context9.t0);
+        case 65:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9, this, [[48, 62]]);
+  }));
+  return function (_x9) {
+    return _ref18.apply(this, arguments);
+  };
+}();
+
+/**
+ * Add a content insertion entry
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {number} insertionTime - Time in seconds (float)
+ * @param {boolean=} sinceStart - If specified, time specified will be elapsed seconds
+ * since stream start, otherwise, time will be elapsed since epoch
+ * @param {number=} duration - Time in seconds (float). Default: 20.0
+ * @param {string} targetHash - The target content object hash (playable)
+ * @param {boolean=} remove - If specified, will remove the inseration at the exact 'time' (instead of adding)
+ *
+ * @return {Promise<Object>} - Insertions, as well as any errors from bad insertions
+ */
+exports.StreamInsertion = /*#__PURE__*/function () {
+  var _ref20 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(_ref19) {
+    var name, insertionTime, _ref19$sinceStart, sinceStart, duration, targetHash, _ref19$remove, remove, offeringMeta, insertionInfo, audioAbrDuration, videoAbrDuration, objectId, libraryId, mainMeta, fabURI, edgeWriteToken, edgeMeta, recordings, sequence, streamStartTime, period, playoutConfig, insertions, res, errs, currentTime, insertionDone, newInsertion, i;
+    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          name = _ref19.name, insertionTime = _ref19.insertionTime, _ref19$sinceStart = _ref19.sinceStart, sinceStart = _ref19$sinceStart === void 0 ? false : _ref19$sinceStart, duration = _ref19.duration, targetHash = _ref19.targetHash, _ref19$remove = _ref19.remove, remove = _ref19$remove === void 0 ? false : _ref19$remove;
+          _context10.next = 3;
+          return this.ContentObjectMetadata({
+            versionHash: targetHash,
+            metadataSubtree: "/offerings/default"
+          });
+        case 3:
+          offeringMeta = _context10.sent;
+          insertionInfo = {
+            duration_sec: 0 // Minimum of video and audio duration
+          };
+
+          ["video", "audio"].forEach(function (mt) {
+            var stream = offeringMeta.media_struct.streams[mt];
+            insertionInfo[mt] = {
+              seg_duration_sec: stream.optimum_seg_dur["float"],
+              duration_sec: stream.duration["float"],
+              frame_rate_rat: stream.rate
+            };
+            if (insertionInfo.duration_sec === 0 || stream.duration["float"] < insertionInfo.duration_sec) {
+              insertionInfo.duration_sec = stream.duration["float"];
+            }
+          });
+          audioAbrDuration = insertionInfo.audio.seg_duration_sec;
+          videoAbrDuration = insertionInfo.video.seg_duration_sec;
+          if (!(audioAbrDuration === 0 || videoAbrDuration === 0)) {
+            _context10.next = 10;
+            break;
+          }
+          throw new Error("Bad segment duration hash:", targetHash);
+        case 10:
+          if (!(duration === undefined)) {
+            _context10.next = 14;
+            break;
+          }
+          duration = insertionInfo.duration_sec; // Use full duration of the insertion
+          _context10.next = 16;
+          break;
+        case 14:
+          if (!(duration > insertionInfo.duration_sec)) {
+            _context10.next = 16;
+            break;
+          }
+          throw new Error("Bad duration - larger than insertion object duration", insertionInfo.duration_sec);
+        case 16:
+          objectId = name;
+          _context10.next = 19;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 19:
+          libraryId = _context10.sent;
+          _context10.next = 22;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 22:
+          mainMeta = _context10.sent;
+          fabURI = mainMeta.live_recording.fabric_config.ingress_node_api; // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          this.SetNodes({
+            fabricURIs: [fabURI]
+          });
+          edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          _context10.next = 29;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken
+          });
+        case 29:
+          edgeMeta = _context10.sent;
+          // Find stream start time (from the most recent recording section)
+          recordings = edgeMeta.live_recording.recordings;
+          sequence = 1;
+          streamStartTime = 0;
+          if (recordings != undefined && recordings.recording_sequence != undefined) {
+            // We have at least one recording - check if still active
+            sequence = recordings.recording_sequence;
+            period = recordings.live_offering[sequence - 1];
+            if (period.end_time_epoch_sec > 0) {
+              // The last period is closed - apply insertions to the next period
+              sequence++;
+            } else {
+              // The period is active
+              streamStartTime = period.start_time_epoch_sec;
+            }
+          }
+          if (!(streamStartTime === 0)) {
+            _context10.next = 37;
+            break;
+          }
+          if (!(sinceStart === false)) {
+            _context10.next = 37;
+            break;
+          }
+          throw new Error("Stream not running - must use 'time since start'");
+        case 37:
+          // Find the current period playout configuration
+          if (edgeMeta.live_recording.playout_config.interleaves === undefined) {
+            edgeMeta.live_recording.playout_config.interleaves = {};
+          }
+          if (edgeMeta.live_recording.playout_config.interleaves[sequence] === undefined) {
+            edgeMeta.live_recording.playout_config.interleaves[sequence] = [];
+          }
+          playoutConfig = edgeMeta.live_recording.playout_config;
+          insertions = playoutConfig.interleaves[sequence];
+          res = {};
+          if (!sinceStart) {
+            insertionTime = insertionTime - streamStartTime;
+          }
+
+          // Assume insertions are sorted by insertion time
+          errs = [];
+          currentTime = -1;
+          insertionDone = false;
+          newInsertion = {
+            insertion_time: insertionTime,
+            duration: duration,
+            audio_abr_duration: audioAbrDuration,
+            video_abr_duration: videoAbrDuration,
+            playout: "/qfab/" + targetHash + "/rep/playout" // TO FIX - should be a link
+          };
+          i = 0;
+        case 48:
+          if (!(i < insertions.length)) {
+            _context10.next = 63;
+            break;
+          }
+          if (insertions[i].insertion_time <= currentTime) {
+            // Bad insertion - must be later than current time
+            append(errs, "Bad insertion - time:", insertions[i].insertion_time);
+          }
+          if (!remove) {
+            _context10.next = 56;
+            break;
+          }
+          if (!(insertions[i].insertion_time === insertionTime)) {
+            _context10.next = 54;
+            break;
+          }
+          insertions.splice(i, 1);
+          return _context10.abrupt("break", 63);
+        case 54:
+          _context10.next = 60;
+          break;
+        case 56:
+          if (!(insertions[i].insertion_time > insertionTime)) {
+            _context10.next = 60;
+            break;
+          }
+          if (i > 0) {
+            insertions = [].concat(_toConsumableArray(insertions.splice(0, i)), [newInsertion], _toConsumableArray(insertions.splice(i)));
+          } else {
+            insertions = [newInsertion].concat(_toConsumableArray(insertions.splice(i)));
+          }
+          insertionDone = true;
+          return _context10.abrupt("break", 63);
+        case 60:
+          i++;
+          _context10.next = 48;
+          break;
+        case 63:
+          if (!remove && !insertionDone) {
+            // Add to the end of the insertions list
+            console.log("Add insertion at the end");
+            insertions = [].concat(_toConsumableArray(insertions), [newInsertion]);
+          }
+          playoutConfig.interleaves[sequence] = insertions;
+
+          // Store the new insertions in the write token
+          _context10.next = 67;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            metadataSubtree: "/live_recording/playout_config",
+            metadata: edgeMeta.live_recording.playout_config
+          });
+        case 67:
+          res.errors = errs;
+          res.insertions = insertions;
+          return _context10.abrupt("return", res);
+        case 70:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10, this);
+  }));
+  return function (_x10) {
+    return _ref20.apply(this, arguments);
+  };
+}();
+
+/**
+ * Configure the stream based on built-in logic and optional custom settings.
+ *
+ * Custom settings format:
+ *    {
+ *      "audio" {
+ *        "1" : {  // This is the stream index
+ *          "tags" : "language: english",
+ *          "codec" : "aac",
+ *          "bitrate": 204000,
+ *          "record":  true,
+ *          "recording_bitrate" : 192000,
+ *          "recording_channels" : 2,
+ *          "playout": bool
+ *          "playout_label": "English (Stereo)"
+ *        },
+ *        "3": {
+ *          ...
+ *        }
+ *      }
+ *    }
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ * @param {Object=} customSettings - Additional options to customize configuration settings
+ * @param {Object=} probeMetadata - Metadata for the probe. If not specified, a new probe will be configured
+ * @return {Promise<Object>} - The status response for the stream
+ *
+ */
+exports.StreamConfig = /*#__PURE__*/function () {
+  var _ref22 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(_ref21) {
+    var name, _ref21$customSettings, customSettings, probeMetadata, objectId, status, libraryId, probe, mainMeta, userConfig, parsedName, hostName, streamUrl, nodes, node, endpoint, probeUrl, lc, liveRecordingConfig, e, writeToken;
+    return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          name = _ref21.name, _ref21$customSettings = _ref21.customSettings, customSettings = _ref21$customSettings === void 0 ? {} : _ref21$customSettings, probeMetadata = _ref21.probeMetadata;
+          objectId = name;
+          status = {
+            name: name
+          };
+          _context11.next = 5;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 5:
+          libraryId = _context11.sent;
+          status.library_id = libraryId;
+          status.object_id = objectId;
+          probe = probeMetadata;
+          _context11.next = 11;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 11:
+          mainMeta = _context11.sent;
+          userConfig = mainMeta.live_recording_config;
+          status.user_config = userConfig;
+
+          // Get node URI from user config
+          parsedName = userConfig.url.replace("udp://", "https://").replace("rtmp://", "https://").replace("srt://", "https://");
+          hostName = new URL(parsedName).hostname;
+          streamUrl = new URL(userConfig.url);
+          this.Log("Retrieving nodes - matching: ".concat(hostName));
+          _context11.next = 20;
+          return this.SpaceNodes({
+            matchEndpoint: hostName
+          });
+        case 20:
+          nodes = _context11.sent;
+          if (!(nodes.length < 1)) {
+            _context11.next = 24;
+            break;
+          }
+          status.error = "No node matching stream URL " + streamUrl.href;
+          return _context11.abrupt("return", status);
+        case 24:
+          node = {
+            endpoints: nodes[0].services.fabric_api.urls,
+            id: nodes[0].id
+          };
+          status.node = node;
+          endpoint = node.endpoints[0];
+          if (probe) {
+            _context11.next = 53;
+            break;
+          }
+          this.SetNodes({
+            fabricURIs: [endpoint]
+          });
+
+          // Probe the stream
+          probe = {};
+          _context11.prev = 30;
+          _context11.next = 33;
+          return this.Rep({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "probe"
+          });
+        case 33:
+          probeUrl = _context11.sent;
+          _context11.t0 = this.utils;
+          _context11.next = 37;
+          return HttpClient.Fetch(probeUrl, {
+            body: JSON.stringify({
+              "filename": streamUrl.href,
+              "listen": true
+            }),
+            method: "POST"
+          });
+        case 37:
+          _context11.t1 = _context11.sent;
+          _context11.next = 40;
+          return _context11.t0.ResponseToJson.call(_context11.t0, _context11.t1);
+        case 40:
+          probe = _context11.sent;
+          if (!probe.errors) {
+            _context11.next = 43;
+            break;
+          }
+          throw probe.errors[0];
+        case 43:
+          _context11.next = 52;
+          break;
+        case 45:
+          _context11.prev = 45;
+          _context11.t2 = _context11["catch"](30);
+          if (!(_context11.t2.code === "ETIMEDOUT")) {
+            _context11.next = 51;
+            break;
+          }
+          throw "Stream probe time out - make sure the stream source is available";
+        case 51:
+          throw _context11.t2;
+        case 52:
+          probe.format.filename = streamUrl.href;
+        case 53:
+          // Create live recording config
+          lc = new LiveConf(probe, node.id, endpoint, false, false, true);
+          liveRecordingConfig = lc.generateLiveConf({
+            customSettings: customSettings
+          }); // Store live recording config into the stream object
+          _context11.next = 57;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 57:
+          e = _context11.sent;
+          writeToken = e.write_token;
+          _context11.next = 61;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: "live_recording",
+            metadata: liveRecordingConfig.live_recording
+          });
+        case 61:
+          _context11.next = 63;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: "live_recording_config/probe_info",
+            metadata: probe
+          });
+        case 63:
+          _context11.next = 65;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Apply live stream configuration"
+          });
+        case 65:
+          status.fin = _context11.sent;
+          return _context11.abrupt("return", status);
+        case 67:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11, this, [[30, 45]]);
+  }));
+  return function (_x11) {
+    return _ref22.apply(this, arguments);
+  };
+}();
+
+/**
+ * List the pre-allocated URLs for a site
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} siteId - ID of the live stream site object
+ *
+ * @return {Promise<Object>} - The list of stream URLs
+ */
+exports.StreamListUrls = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+  var _this2 = this;
+  var _ref24,
+    siteId,
+    STATUS_MAP,
+    tenantContractId,
+    streamMetadata,
+    activeUrlMap,
+    streamUrlStatus,
+    streamUrls,
+    _args13 = arguments;
+  return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+    while (1) switch (_context13.prev = _context13.next) {
+      case 0:
+        _ref24 = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : {}, siteId = _ref24.siteId;
+        _context13.prev = 1;
+        STATUS_MAP = {
+          UNCONFIGURED: "unconfigured",
+          UNINITIALIZED: "uninitialized",
+          INACTIVE: "inactive",
+          STOPPED: "stopped",
+          STARTING: "starting",
+          RUNNING: "running",
+          STALLED: "stalled"
+        };
+        if (siteId) {
+          _context13.next = 12;
+          break;
+        }
+        _context13.next = 6;
+        return this.userProfileClient.TenantContractId();
+      case 6:
+        tenantContractId = _context13.sent;
+        if (tenantContractId) {
+          _context13.next = 9;
+          break;
+        }
+        throw Error("No tenant contract ID configured");
+      case 9:
+        _context13.next = 11;
+        return this.ContentObjectMetadata({
+          libraryId: tenantContractId.replace("iten", "ilib"),
+          objectId: tenantContractId.replace("iten", "iq__"),
+          metadataSubtree: "public/sites/live_streams"
+        });
+      case 11:
+        siteId = _context13.sent;
+      case 12:
+        _context13.t0 = this;
+        _context13.next = 15;
+        return this.ContentObjectLibraryId({
+          objectId: siteId
+        });
+      case 15:
+        _context13.t1 = _context13.sent;
+        _context13.t2 = siteId;
+        _context13.t3 = {
+          libraryId: _context13.t1,
+          objectId: _context13.t2,
+          metadataSubtree: "public/asset_metadata/live_streams",
+          resolveLinks: true,
+          resolveIgnoreErrors: true,
+          resolveIncludeSource: true
+        };
+        _context13.next = 20;
+        return _context13.t0.ContentObjectMetadata.call(_context13.t0, _context13.t3);
+      case 20:
+        streamMetadata = _context13.sent;
+        activeUrlMap = {};
+        _context13.next = 24;
+        return this.utils.LimitedMap(10, Object.keys(streamMetadata || {}), /*#__PURE__*/function () {
+          var _ref25 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(slug) {
+            var stream, versionHash, objectId, libraryId, status, streamMeta, url, isActive;
+            return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+              while (1) switch (_context12.prev = _context12.next) {
+                case 0:
+                  stream = streamMetadata[slug];
+                  if (stream && stream["."] && stream["."].source) {
+                    versionHash = stream["."].source;
+                  }
+                  if (!versionHash) {
+                    _context12.next = 16;
+                    break;
+                  }
+                  objectId = _this2.utils.DecodeVersionHash(versionHash).objectId;
+                  _context12.next = 6;
+                  return _this2.ContentObjectLibraryId({
+                    objectId: objectId
+                  });
+                case 6:
+                  libraryId = _context12.sent;
+                  _context12.next = 9;
+                  return _this2.StreamStatus({
+                    name: objectId
+                  });
+                case 9:
+                  status = _context12.sent;
+                  _context12.next = 12;
+                  return _this2.ContentObjectMetadata({
+                    objectId: objectId,
+                    libraryId: libraryId,
+                    select: ["live_recording_config/reference_url",
+                    // live_recording_config/url is the old path
+                    "live_recording_config/url"]
+                  });
+                case 12:
+                  streamMeta = _context12.sent;
+                  url = streamMeta.live_recording_config.reference_url || streamMeta.live_recording_config.url;
+                  isActive = [STATUS_MAP.STARTING, STATUS_MAP.RUNNING, STATUS_MAP.STALLED, STATUS_MAP.STOPPED].includes(status.state);
+                  if (url && isActive) {
+                    activeUrlMap[url] = true;
+                  }
+                case 16:
+                case "end":
+                  return _context12.stop();
+              }
+            }, _callee12);
+          }));
+          return function (_x12) {
+            return _ref25.apply(this, arguments);
+          };
+        }());
+      case 24:
+        streamUrlStatus = {};
+        _context13.t4 = this;
+        _context13.next = 28;
+        return this.ContentObjectLibraryId({
+          objectId: siteId
+        });
+      case 28:
+        _context13.t5 = _context13.sent;
+        _context13.t6 = siteId;
+        _context13.t7 = {
+          libraryId: _context13.t5,
+          objectId: _context13.t6,
+          metadataSubtree: "/live_stream_urls",
+          resolveLinks: true,
+          resolveIgnoreErrors: true
+        };
+        _context13.next = 33;
+        return _context13.t4.ContentObjectMetadata.call(_context13.t4, _context13.t7);
+      case 33:
+        streamUrls = _context13.sent;
+        if (streamUrls) {
+          _context13.next = 36;
+          break;
+        }
+        throw Error("No pre-allocated URLs configured");
+      case 36:
+        Object.keys(streamUrls || {}).forEach(function (protocol) {
+          streamUrlStatus[protocol] = streamUrls[protocol].map(function (url) {
+            return {
+              url: url,
+              active: activeUrlMap[url] || false
+            };
+          });
+        });
+        return _context13.abrupt("return", streamUrlStatus);
+      case 40:
+        _context13.prev = 40;
+        _context13.t8 = _context13["catch"](1);
+        console.error(_context13.t8);
+      case 43:
+      case "end":
+        return _context13.stop();
+    }
+  }, _callee13, this, [[1, 40]]);
+}));
+
+/**
+ * Copy a portion of a live stream recording into a standard VoD object using the zero-copy content fabric API
+ *
+ * Limitations:
+ * - currently requires the target object to be pre-created and have content encryption keys (CAPS)
+ * - for audio and video to be sync'd, the live stream needs to have the beginning of the desired recording period
+ * - for an event stream, make sure the TTL is long enough to allow running the live-to-vod command before the beginning of the recording expires
+ * - for 24/7 streams, make sure to reset the stream before the desired recording (as to create a new recording period) and have the TTL long enough
+ *  to allow running the live-to-vod command before the beginning of the recording expires.
+ * - startTime and endTime are not currently implemented by this method
+ *
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream
+ * @param {string} targetObjectId - Object ID of the target VOD object
+ * @param {string=} eventId -
+ * @param {boolean=} finalize - If enabled, target object will be finalized after copy to vod operations
+ * @param {number=} recordingPeriod - Determines which recording period to copy, which are 0-based. -1 copies the current (or last) period
+ *
+ * @return {Promise<Object>} - The status response for the stream
+ */
+
+/*
+   Example fabric API flow:
+
+     https://host-76-74-34-194.contentfabric.io/qlibs/ilib24CtWSJeVt9DiAzym8jB6THE9e7H/q/$QWT/call/media/live_to_vod/init -d @r1 -H "Authorization: Bearer $TOK"
+
+     {
+       "live_qhash": "hq__5Zk1jSN8vNLUAXjQwMJV8F8J8ESXNvmVKkhaXySmGc1BXnJPG2FvvaXee4CXqvFHuGuU3fqLJc",
+       "start_time": "",
+       "end_time": "",
+       "recording_period": -1,
+       "streams": ["video", "audio"],
+       "variant_key": "default"
+     }
+
+     https://host-76-74-34-194.contentfabric.io/qlibs/ilib24CtWSJeVt9DiAzym8jB6THE9e7H/q/$QWT/call/media/abr_mezzanine/init  -H "Authorization: Bearer $TOK" -d @r2
+
+     {
+
+       "abr_profile": { ...  },
+       "offering_key": "default",
+       "prod_master_hash": "tqw__HSQHBt7vYxWfCMPH5yXwKTfhdPcQ4Lcs9WUMUbTtnMbTZPTLo4BfJWPMGpoy1Dpv1wWQVtUtAtAr429TnVs",
+       "variant_key": "default",
+       "keep_other_streams": false
+     }
+
+     https://host-76-74-34-194.contentfabric.io/qlibs/ilib24CtWSJeVt9DiAzym8jB6THE9e7H/q/$QWT/call/media/live_to_vod/copy -d '{"variant_key":"","offering_key":""}' -H "Authorization: Bearer $TOK"
+
+
+     https://host-76-74-34-194.contentfabric.io/qlibs/ilib24CtWSJeVt9DiAzym8jB6THE9e7H/q/$QWT/call/media/abr_mezzanine/offerings/default/finalize -d '{}' -H "Authorization: Bearer $TOK"
+
+ */
+
+exports.StreamCopyToVod = /*#__PURE__*/function () {
+  var _ref27 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14(_ref26) {
+    var name, targetObjectId, eventId, _ref26$streams, streams, _ref26$finalize, finalize, _ref26$recordingPerio, recordingPeriod, _ref26$startTime, startTime, _ref26$endTime, endTime, objectId, abrProfile, status, libraryId, targetLibraryId, kmsAddress, kmsCapId, kmsCap, liveHash, event, _yield$this$EditConte2, writeToken, abrMezInitBody, finalizeResponse;
+    return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          name = _ref26.name, targetObjectId = _ref26.targetObjectId, eventId = _ref26.eventId, _ref26$streams = _ref26.streams, streams = _ref26$streams === void 0 ? null : _ref26$streams, _ref26$finalize = _ref26.finalize, finalize = _ref26$finalize === void 0 ? true : _ref26$finalize, _ref26$recordingPerio = _ref26.recordingPeriod, recordingPeriod = _ref26$recordingPerio === void 0 ? -1 : _ref26$recordingPerio, _ref26$startTime = _ref26.startTime, startTime = _ref26$startTime === void 0 ? "" : _ref26$startTime, _ref26$endTime = _ref26.endTime, endTime = _ref26$endTime === void 0 ? "" : _ref26$endTime;
+          objectId = name;
+          abrProfile = require("../abr_profiles/abr_profile_live_to_vod.js");
+          _context14.next = 5;
+          return this.StreamStatus({
+            name: name
+          });
+        case 5:
+          status = _context14.sent;
+          libraryId = status.library_id;
+          this.Log("Copying stream ".concat(name, " to target ").concat(targetObjectId));
+          ValidateObject(targetObjectId);
+          _context14.next = 11;
+          return this.ContentObjectLibraryId({
+            objectId: targetObjectId
+          });
+        case 11:
+          targetLibraryId = _context14.sent;
+          _context14.next = 14;
+          return this.authClient.KMSAddress({
+            objectId: targetObjectId
+          });
+        case 14:
+          kmsAddress = _context14.sent;
+          kmsCapId = "eluv.caps.ikms".concat(this.utils.AddressToHash(kmsAddress));
+          _context14.next = 18;
+          return this.ContentObjectMetadata({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            metadataSubtree: kmsCapId
+          });
+        case 18:
+          kmsCap = _context14.sent;
+          if (kmsCap) {
+            _context14.next = 21;
+            break;
+          }
+          throw Error("No content encryption key set for object ".concat(targetObjectId));
+        case 21:
+          _context14.prev = 21;
+          status.live_object_id = objectId;
+          _context14.next = 25;
+          return this.LatestVersionHash({
+            objectId: objectId,
+            libraryId: libraryId
+          });
+        case 25:
+          liveHash = _context14.sent;
+          status.live_hash = liveHash;
+          if (!eventId) {
+            _context14.next = 32;
+            break;
+          }
+          _context14.next = 30;
+          return this.CueInfo({
+            eventId: eventId,
+            status: status
+          });
+        case 30:
+          event = _context14.sent;
+          if (event.eventStart && event.eventEnd) {
+            startTime = event.eventStart;
+            endTime = event.eventEnd;
+          }
+        case 32:
+          _context14.next = 34;
+          return this.EditContentObject({
+            objectId: targetObjectId,
+            libraryId: targetLibraryId
+          });
+        case 34:
+          _yield$this$EditConte2 = _context14.sent;
+          writeToken = _yield$this$EditConte2.writeToken;
+          status.target_object_id = targetObjectId;
+          status.target_library_id = targetLibraryId;
+          status.target_write_token = writeToken;
+          this.Log("Process live source (takes around 20 sec per hour of content)");
+          _context14.next = 42;
+          return this.CallBitcodeMethod({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            writeToken: writeToken,
+            method: "/media/live_to_vod/init",
+            body: {
+              "live_qhash": liveHash,
+              "start_time": startTime,
+              // eg. "2023-10-03T02:09:02.00Z",
+              "end_time": endTime,
+              // eg. "2023-10-03T02:15:00.00Z",
+              "streams": streams,
+              "recording_period": recordingPeriod,
+              "variant_key": "default"
+            },
+            constant: false,
+            format: "text"
+          });
+        case 42:
+          abrMezInitBody = {
+            abr_profile: abrProfile,
+            "offering_key": "default",
+            "prod_master_hash": writeToken,
+            "variant_key": "default",
+            "keep_other_streams": false
+          };
+          _context14.next = 45;
+          return this.CallBitcodeMethod({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            writeToken: writeToken,
+            method: "/media/abr_mezzanine/init",
+            body: abrMezInitBody,
+            constant: false,
+            format: "text"
+          });
+        case 45:
+          _context14.prev = 45;
+          _context14.next = 48;
+          return this.CallBitcodeMethod({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            writeToken: writeToken,
+            method: "/media/live_to_vod/copy",
+            body: {},
+            constant: false,
+            format: "text"
+          });
+        case 48:
+          _context14.next = 54;
+          break;
+        case 50:
+          _context14.prev = 50;
+          _context14.t0 = _context14["catch"](45);
+          console.error("Unable to call /media/live_to_vod/copy", _context14.t0);
+          throw _context14.t0;
+        case 54:
+          _context14.next = 56;
+          return this.CallBitcodeMethod({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            writeToken: writeToken,
+            method: "/media/abr_mezzanine/offerings/default/finalize",
+            body: abrMezInitBody,
+            constant: false,
+            format: "text"
+          });
+        case 56:
+          if (!finalize) {
+            _context14.next = 61;
+            break;
+          }
+          _context14.next = 59;
+          return this.FinalizeContentObject({
+            libraryId: targetLibraryId,
+            objectId: targetObjectId,
+            writeToken: writeToken,
+            commitMessage: "Live Stream to VoD"
+          });
+        case 59:
+          finalizeResponse = _context14.sent;
+          status.target_hash = finalizeResponse.hash;
+        case 61:
+          // Clean up unnecessary status items
+          delete status.playout_urls;
+          delete status.lro_status_url;
+          delete status.recording_period;
+          delete status.recording_period_sequence;
+          delete status.edge_meta_size;
+          delete status.insertions;
+          return _context14.abrupt("return", status);
+        case 70:
+          _context14.prev = 70;
+          _context14.t1 = _context14["catch"](21);
+          this.Log(_context14.t1, true);
+          throw _context14.t1;
+        case 74:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14, this, [[21, 70], [45, 50]]);
+  }));
+  return function (_x13) {
+    return _ref27.apply(this, arguments);
+  };
+}();
+
+/**
+ * Remove a watermark for a live stream
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
+ * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
+ * @param {Array<string>} types - Specify which type of watermark to remove. Possible values:
+ * - "image"
+ * - "text"
+ * - "forensic"
+ * @param {boolean=} finalize - If enabled, target object will be finalized after removing watermark
+ *
+ * @return {Promise<Object>} - The finalize response
+ */
+exports.StreamRemoveWatermark = /*#__PURE__*/function () {
+  var _ref29 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15(_ref28) {
+    var libraryId, objectId, writeToken, types, _ref28$finalize, finalize, _yield$this$EditConte3, edgeWriteToken, metadataPath, objectMetadata, finalizeResponse;
+    return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
+        case 0:
+          libraryId = _ref28.libraryId, objectId = _ref28.objectId, writeToken = _ref28.writeToken, types = _ref28.types, _ref28$finalize = _ref28.finalize, finalize = _ref28$finalize === void 0 ? true : _ref28$finalize;
+          ValidateObject(objectId);
+          if (libraryId) {
+            _context15.next = 6;
+            break;
+          }
+          _context15.next = 5;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 5:
+          libraryId = _context15.sent;
+        case 6:
+          if (writeToken) {
+            _context15.next = 11;
+            break;
+          }
+          _context15.next = 9;
+          return this.EditContentObject({
+            objectId: objectId,
+            libraryId: libraryId
+          });
+        case 9:
+          _yield$this$EditConte3 = _context15.sent;
+          writeToken = _yield$this$EditConte3.writeToken;
+        case 11:
+          this.Log("Removing watermark types: ".concat(types.join(", "), " ").concat(libraryId, " ").concat(objectId));
+          _context15.next = 14;
+          return this.ContentObjectMetadata({
+            objectId: objectId,
+            libraryId: libraryId,
+            metadataSubtree: "/live_recording/fabric_config/edge_write_token"
+          });
+        case 14:
+          edgeWriteToken = _context15.sent;
+          metadataPath = "live_recording/playout_config";
+          _context15.next = 18;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: metadataPath,
+            resolveLinks: false
+          });
+        case 18:
+          objectMetadata = _context15.sent;
+          if (objectMetadata) {
+            _context15.next = 21;
+            break;
+          }
+          throw Error("Stream object must be configured before removing a watermark");
+        case 21:
+          types.forEach(function (type) {
+            if (type === "text") {
+              delete objectMetadata.simple_watermark;
+            } else if (type === "image") {
+              delete objectMetadata.image_watermark;
+            } else if (type === "forensic") {
+              delete objectMetadata.forensic_watermark;
+            }
+          });
+          _context15.next = 24;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: metadataPath,
+            metadata: objectMetadata
+          });
+        case 24:
+          if (!edgeWriteToken) {
+            _context15.next = 27;
+            break;
+          }
+          _context15.next = 27;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            metadataSubtree: metadataPath,
+            metadata: objectMetadata
+          });
+        case 27:
+          if (!finalize) {
+            _context15.next = 32;
+            break;
+          }
+          _context15.next = 30;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Watermark removed"
+          });
+        case 30:
+          finalizeResponse = _context15.sent;
+          return _context15.abrupt("return", finalizeResponse);
+        case 32:
+        case "end":
+          return _context15.stop();
+      }
+    }, _callee15, this);
+  }));
+  return function (_x14) {
+    return _ref29.apply(this, arguments);
+  };
+}();
+
+/**
+ * Create a watermark for a live stream
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
+ * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
+ * @param {Object} simpleWatermark - Text watermark
+ * @param {Object} imageWatermark - Image watermark
+ * @param {Object} forensicWatermark - Forensic watermark
+ * @param {boolean=} finalize - If enabled, target object will be finalized after adding watermark
+ * Watermark examples:
+ *
+ * Simple Watermark:
+   {
+     "font_color": "",
+     "font_relative_height": 0,
+     "shadow": false,
+     "template": "",
+     "timecode": "",
+     "timecode_rate": 0,
+     "x": "",
+     "y": ""
+   }
+ *
+ * Image watermark:
+   {
+     "image": "",
+     "align_h": "",
+     "align_v": "",
+     "target_video_height": 0,
+     "wm_enabled": false
+   }
+ *
+ * Forensic watermark:
+   {
+     "algo": 6,
+     "forensic_duration": 0,
+     "forensic_start": "",
+     "image_a": <path_to_image>,
+     "image_b": <path_to_image>,
+     "is_stub": true,
+     "payload_bit_nb": 23,
+     "wm_enabled": true
+   }
+ *
+ *
+ * @return {Promise<Object>} - The finalize response
+ */
+exports.StreamAddWatermark = /*#__PURE__*/function () {
+  var _ref31 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16(_ref30) {
+    var libraryId, objectId, writeToken, simpleWatermark, imageWatermark, forensicWatermark, _ref30$finalize, finalize, _yield$this$EditConte4, edgeWriteToken, watermarkType, metadataPath, objectMetadata, watermarkArgCount, response, finalizeResponse;
+    return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          libraryId = _ref30.libraryId, objectId = _ref30.objectId, writeToken = _ref30.writeToken, simpleWatermark = _ref30.simpleWatermark, imageWatermark = _ref30.imageWatermark, forensicWatermark = _ref30.forensicWatermark, _ref30$finalize = _ref30.finalize, finalize = _ref30$finalize === void 0 ? true : _ref30$finalize;
+          ValidateObject(objectId);
+          if (libraryId) {
+            _context16.next = 6;
+            break;
+          }
+          _context16.next = 5;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 5:
+          libraryId = _context16.sent;
+        case 6:
+          if (writeToken) {
+            _context16.next = 11;
+            break;
+          }
+          _context16.next = 9;
+          return this.EditContentObject({
+            objectId: objectId,
+            libraryId: libraryId
+          });
+        case 9:
+          _yield$this$EditConte4 = _context16.sent;
+          writeToken = _yield$this$EditConte4.writeToken;
+        case 11:
+          _context16.next = 13;
+          return this.ContentObjectMetadata({
+            objectId: objectId,
+            libraryId: libraryId,
+            metadataSubtree: "/live_recording/fabric_config/edge_write_token"
+          });
+        case 13:
+          edgeWriteToken = _context16.sent;
+          watermarkType = imageWatermark ? "image" : forensicWatermark ? "forensic" : "text";
+          metadataPath = "live_recording/playout_config";
+          this.Log("Adding watermarking type: ".concat(watermarkType, " ").concat(libraryId, " ").concat(objectId));
+          _context16.next = 19;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: metadataPath,
+            resolveLinks: false
+          });
+        case 19:
+          objectMetadata = _context16.sent;
+          if (objectMetadata) {
+            _context16.next = 22;
+            break;
+          }
+          throw Error("Stream object must be configured before adding a watermark");
+        case 22:
+          watermarkArgCount = [simpleWatermark, imageWatermark, forensicWatermark].filter(function (i) {
+            return !!i;
+          }).length;
+          console.log("watermark arg count", watermarkArgCount);
+          if (!(watermarkArgCount === 0)) {
+            _context16.next = 28;
+            break;
+          }
+          throw Error("No watermark was provided");
+        case 28:
+          if (!(watermarkArgCount > 1)) {
+            _context16.next = 30;
+            break;
+          }
+          throw Error("Only one watermark is allowed");
+        case 30:
+          if (simpleWatermark) {
+            objectMetadata.simple_watermark = simpleWatermark;
+          } else if (imageWatermark) {
+            objectMetadata.image_watermark = imageWatermark;
+          } else if (forensicWatermark) {
+            objectMetadata.forensic_watermark = forensicWatermark;
+          }
+          _context16.next = 33;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadataSubtree: metadataPath,
+            metadata: objectMetadata
+          });
+        case 33:
+          if (!edgeWriteToken) {
+            _context16.next = 36;
+            break;
+          }
+          _context16.next = 36;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: edgeWriteToken,
+            metadataSubtree: metadataPath,
+            metadata: objectMetadata
+          });
+        case 36:
+          response = {
+            "imageWatermark": objectMetadata.image_watermark,
+            "textWatermark": objectMetadata.simple_watermark,
+            "forensicWatermark": objectMetadata.forensic_watermark
+          };
+          if (!finalize) {
+            _context16.next = 42;
+            break;
+          }
+          _context16.next = 40;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Watermark set"
+          });
+        case 40:
+          finalizeResponse = _context16.sent;
+          response.hash = finalizeResponse.hash;
+        case 42:
+          return _context16.abrupt("return", response);
+        case 43:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16, this);
+  }));
+  return function (_x15) {
+    return _ref31.apply(this, arguments);
+  };
+}();
+
+/**
+ * Audit the specified live stream against several content fabric nodes
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} objectId - Object ID of the live stream
+ * @param {string=} versionHash - Version hash of the live stream -- if not specified, latest version is returned
+ * @param {string=} salt - base64-encoded byte sequence for salting the audit hash
+ * @param {Array<number>=} samples - list of percentages (0.0 - <1.0) used for sampling the content part list, up to 3
+ * @param {string=} authorizationToken - Additional authorization token for this request
+ *
+ * @returns {Promise<Object>} - Response describing audit results
+ */
+exports.AuditStream = /*#__PURE__*/function () {
+  var _ref33 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17(_ref32) {
+    var objectId, versionHash, salt, samples, authorizationToken;
+    return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+      while (1) switch (_context17.prev = _context17.next) {
+        case 0:
+          objectId = _ref32.objectId, versionHash = _ref32.versionHash, salt = _ref32.salt, samples = _ref32.samples, authorizationToken = _ref32.authorizationToken;
+          _context17.next = 3;
+          return ContentObjectAudit.AuditContentObject({
+            client: this,
+            objectId: objectId,
+            versionHash: versionHash,
+            salt: salt,
+            samples: samples,
+            live: true,
+            authorizationToken: authorizationToken
+          });
+        case 3:
+          return _context17.abrupt("return", _context17.sent);
+        case 4:
+        case "end":
+          return _context17.stop();
+      }
+    }, _callee17, this);
+  }));
+  return function (_x16) {
+    return _ref33.apply(this, arguments);
+  };
+}();