@microsoft/teams-js 2.13.0-beta.1 → 2.13.0

package/dist/MicrosoftTeams.js

@@ -845,6 +845,7 @@ __webpack_require__.d(__webpack_exports__, {
   "location": () => (/* reexport */ location_location),
   "logs": () => (/* reexport */ logs),
   "mail": () => (/* reexport */ mail),
+  "marketplace": () => (/* reexport */ marketplace),
   "media": () => (/* reexport */ media),
   "meeting": () => (/* reexport */ meeting),
   "meetingRoom": () => (/* reexport */ meetingRoom),
@@ -2088,7 +2089,7 @@ var _minRuntimeConfigToUninitialize = {
  * @hidden
  *  Package version.
  */
-var version = "2.13.0-beta.1";
+var version = "2.13.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -7884,6 +7885,7 @@ var videoUtils_generator = (undefined && undefined.__generator) || function (thi
 
 
 
+
 /**
  * @hidden
  * Create a MediaStreamTrack from the media stream with the given streamId and processed by videoFrameHandler.
@@ -7896,8 +7898,28 @@ function processMediaStream(streamId, videoFrameHandler, notifyError) {
                 case 0:
                     _a = createProcessedStreamGenerator;
                     return [4 /*yield*/, getInputVideoTrack(streamId, notifyError)];
-                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), videoFrameHandler,
-                        notifyError])];
+                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), new DefaultTransformer(notifyError, videoFrameHandler)])];
+            }
+        });
+    });
+}
+/**
+ * @hidden
+ * Create a MediaStreamTrack from the media stream with the given streamId and processed by videoFrameHandler.
+ * The videoFrameHandler will receive metadata of the video frame.
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function processMediaStreamWithMetadata(streamId, videoFrameHandler, notifyError) {
+    return videoUtils_awaiter(this, void 0, void 0, function () {
+        var _a;
+        return videoUtils_generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createProcessedStreamGenerator;
+                    return [4 /*yield*/, getInputVideoTrack(streamId, notifyError)];
+                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), new TransformerWithMetadata(notifyError, videoFrameHandler)])];
             }
         });
     });
@@ -7942,7 +7964,7 @@ function getInputVideoTrack(streamId, notifyError) {
  * The processed frames are then enqueued to the generator.
  * The generator can be registered back to the media stream so that the host can get the processed frames.
  */
-function createProcessedStreamGenerator(videoTrack, videoFrameHandler, notifyError) {
+function createProcessedStreamGenerator(videoTrack, transformer) {
     if (inServerSideRenderingEnvironment()) {
         throw errorNotSupportedOnPlatform;
     }
@@ -7952,48 +7974,301 @@ function createProcessedStreamGenerator(videoTrack, videoFrameHandler, notifyErr
     var MediaStreamTrackGenerator = window['MediaStreamTrackGenerator'];
     var generator = new MediaStreamTrackGenerator({ kind: 'video' });
     var sink = generator.writable;
-    source
-        .pipeThrough(new TransformStream({
-        transform: function (originalFrame, controller) {
-            return videoUtils_awaiter(this, void 0, void 0, function () {
-                var timestamp, frameProcessedByApp, processedFrame, error_2;
-                return videoUtils_generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            timestamp = originalFrame.timestamp;
-                            if (!(timestamp !== null)) return [3 /*break*/, 5];
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, videoFrameHandler({ videoFrame: originalFrame })];
-                        case 2:
-                            frameProcessedByApp = _a.sent();
-                            processedFrame = new VideoFrame(frameProcessedByApp, {
-                                // we need the timestamp to be unchanged from the oirginal frame, so we explicitly set it here.
-                                timestamp: timestamp,
-                            });
-                            controller.enqueue(processedFrame);
-                            originalFrame.close();
-                            frameProcessedByApp.close();
-                            return [3 /*break*/, 4];
-                        case 3:
-                            error_2 = _a.sent();
-                            originalFrame.close();
-                            notifyError(error_2);
-                            return [3 /*break*/, 4];
-                        case 4: return [3 /*break*/, 6];
-                        case 5:
-                            notifyError('timestamp of the original video frame is null');
-                            _a.label = 6;
-                        case 6: return [2 /*return*/];
-                    }
-                });
-            });
-        },
-    }))
-        .pipeTo(sink);
+    source.pipeThrough(new TransformStream(transformer)).pipeTo(sink);
     return generator;
 }
+/**
+ * @hidden
+ * Error messages during video frame transformation.
+ */
+var VideoFrameTransformErrors;
+(function (VideoFrameTransformErrors) {
+    VideoFrameTransformErrors["TimestampIsNull"] = "timestamp of the original video frame is null";
+    VideoFrameTransformErrors["UnsupportedVideoFramePixelFormat"] = "Unsupported video frame pixel format";
+})(VideoFrameTransformErrors || (VideoFrameTransformErrors = {}));
+var DefaultTransformer = /** @class */ (function () {
+    function DefaultTransformer(notifyError, videoFrameHandler) {
+        var _this = this;
+        this.notifyError = notifyError;
+        this.videoFrameHandler = videoFrameHandler;
+        this.transform = function (originalFrame, controller) { return videoUtils_awaiter(_this, void 0, void 0, function () {
+            var timestamp, frameProcessedByApp, processedFrame, error_2;
+            return videoUtils_generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        timestamp = originalFrame.timestamp;
+                        if (!(timestamp !== null)) return [3 /*break*/, 5];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.videoFrameHandler({ videoFrame: originalFrame })];
+                    case 2:
+                        frameProcessedByApp = _a.sent();
+                        processedFrame = new VideoFrame(frameProcessedByApp, {
+                            // we need the timestamp to be unchanged from the oirginal frame, so we explicitly set it here.
+                            timestamp: timestamp,
+                        });
+                        controller.enqueue(processedFrame);
+                        originalFrame.close();
+                        frameProcessedByApp.close();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        originalFrame.close();
+                        this.notifyError(error_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        this.notifyError(VideoFrameTransformErrors.TimestampIsNull);
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); };
+    }
+    return DefaultTransformer;
+}());
+/**
+ * @hidden
+ * Utility class to parse the header of a one-texture-input texture.
+ */
+var OneTextureHeader = /** @class */ (function () {
+    function OneTextureHeader(headerBuffer, notifyError) {
+        this.headerBuffer = headerBuffer;
+        this.notifyError = notifyError;
+        // Identifier for the texture layout, which is the 4-byte ASCII string "oti1" hardcoded by the host
+        // (oti1 stands for "one texture input version 1")
+        this.ONE_TEXTURE_INPUT_ID = 0x6f746931;
+        this.INVALID_HEADER_ERROR = 'Invalid video frame header';
+        this.UNSUPPORTED_LAYOUT_ERROR = 'Unsupported texture layout';
+        this.headerDataView = new Uint32Array(headerBuffer);
+        // headerDataView will contain the following data:
+        // 0: oneTextureLayoutId
+        // 1: version
+        // 2: frameRowOffset
+        // 3: frameFormat
+        // 4: frameWidth
+        // 5: frameHeight
+        // 6: multiStreamHeaderRowOffset
+        // 7: multiStreamCount
+        if (this.headerDataView.length < 8) {
+            this.notifyError(this.INVALID_HEADER_ERROR);
+            throw new Error(this.INVALID_HEADER_ERROR);
+        }
+        // ensure the texture layout is supported
+        if (this.headerDataView[0] !== this.ONE_TEXTURE_INPUT_ID) {
+            this.notifyError(this.UNSUPPORTED_LAYOUT_ERROR);
+            throw new Error(this.UNSUPPORTED_LAYOUT_ERROR);
+        }
+    }
+    Object.defineProperty(OneTextureHeader.prototype, "oneTextureLayoutId", {
+        get: function () {
+            return this.headerDataView[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "version", {
+        get: function () {
+            return this.headerDataView[1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "frameRowOffset", {
+        get: function () {
+            return this.headerDataView[2];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "frameFormat", {
+        get: function () {
+            return this.headerDataView[3];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "frameWidth", {
+        get: function () {
+            return this.headerDataView[4];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "frameHeight", {
+        get: function () {
+            return this.headerDataView[5];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "multiStreamHeaderRowOffset", {
+        get: function () {
+            return this.headerDataView[6];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OneTextureHeader.prototype, "multiStreamCount", {
+        get: function () {
+            return this.headerDataView[7];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OneTextureHeader;
+}());
+/**
+ * @hidden
+ * Utility class to parse the metadata of a one-texture-input texture.
+ */
+var OneTextureMetadata = /** @class */ (function () {
+    function OneTextureMetadata(metadataBuffer, streamCount) {
+        this.metadataMap = new Map();
+        // Stream id for audio inference metadata, which is the 4-byte ASCII string "1dia" hardcoded by the host
+        // (1dia stands for "audio inference data version 1")
+        this.AUDIO_INFERENCE_RESULT_STREAM_ID = 0x31646961;
+        var metadataDataView = new Uint32Array(metadataBuffer);
+        for (var i = 0, index = 0; i < streamCount; i++) {
+            var streamId = metadataDataView[index++];
+            var streamDataOffset = metadataDataView[index++];
+            var streamDataSize = metadataDataView[index++];
+            var streamData = new Uint8Array(metadataBuffer, streamDataOffset, streamDataSize);
+            this.metadataMap.set(streamId, streamData);
+        }
+    }
+    Object.defineProperty(OneTextureMetadata.prototype, "audioInferenceResult", {
+        get: function () {
+            return this.metadataMap.get(this.AUDIO_INFERENCE_RESULT_STREAM_ID);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OneTextureMetadata;
+}());
+var TransformerWithMetadata = /** @class */ (function () {
+    function TransformerWithMetadata(notifyError, videoFrameHandler) {
+        var _this = this;
+        this.notifyError = notifyError;
+        this.videoFrameHandler = videoFrameHandler;
+        this.shouldDiscardAudioInferenceResult = false;
+        this.transform = function (originalFrame, controller) { return videoUtils_awaiter(_this, void 0, void 0, function () {
+            var timestamp, _a, videoFrame, _b, _c, audioInferenceResult, frameProcessedByApp, processedFrame, error_3;
+            return videoUtils_generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        timestamp = originalFrame.timestamp;
+                        if (!(timestamp !== null)) return [3 /*break*/, 6];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.extractVideoFrameAndMetadata(originalFrame)];
+                    case 2:
+                        _a = _d.sent(), videoFrame = _a.videoFrame, _b = _a.metadata, _c = _b === void 0 ? {} : _b, audioInferenceResult = _c.audioInferenceResult;
+                        return [4 /*yield*/, this.videoFrameHandler({ videoFrame: videoFrame, audioInferenceResult: audioInferenceResult })];
+                    case 3:
+                        frameProcessedByApp = _d.sent();
+                        processedFrame = new VideoFrame(frameProcessedByApp, {
+                            // we need the timestamp to be unchanged from the oirginal frame, so we explicitly set it here.
+                            timestamp: timestamp,
+                        });
+                        controller.enqueue(processedFrame);
+                        videoFrame.close();
+                        originalFrame.close();
+                        frameProcessedByApp.close();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_3 = _d.sent();
+                        originalFrame.close();
+                        this.notifyError(error_3);
+                        return [3 /*break*/, 5];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        this.notifyError(VideoFrameTransformErrors.TimestampIsNull);
+                        _d.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * @hidden
+         * Extract video frame and metadata from the given texture.
+         * The given texure should be in NV12 format and the layout of the texture should be:
+         * | Texture layout        |
+         * | :---                  |
+         * | Header                |
+         * | Real video frame data |
+         * | Metadata              |
+         *
+         * The header data is in the first two rows with the following format:
+         * | oneTextureLayoutId | version | frameRowOffset | frameFormat | frameWidth | frameHeight | multiStreamHeaderRowOffset | multiStreamCount | ...   |
+         * |    :---:           | :---:   | :---:          |  :---:      |  :---:     |  :---:      |  :---:                     |  :---:           | :---: |
+         * | 4 bytes            | 4 bytes | 4 bytes        | 4 bytes     | 4 bytes    | 4 bytes     | 4 bytes                    | 4 bytes          | ...   |
+         *
+         * After header, it comes with the real video frame data.
+         * At the end of the texture, it comes with the metadata. The metadata section can contain multiple types of metadata.
+         * Each type of metadata is called a stream. The section is in the following format:
+         * | stream1.id | stream1.dataOffset | stream1.dataSize | stream2.id | stream2.dataOffset | stream2.dataSize | ... | stream1.data | stream2.data | ... |
+         * | :---:      | :---:              | :---:            |  :---:     |  :---:             |  :---:           |:---:|  :---:       | :---:        |:---:|
+         * | 4 bytes    | 4 bytes            | 4 bytes          | 4 bytes    | 4 bytes            | 4 bytes          | ... | ...          | ...          | ... |
+         *
+         * @internal
+         * Limited to Microsoft-internal use
+         */
+        this.extractVideoFrameAndMetadata = function (texture) { return videoUtils_awaiter(_this, void 0, void 0, function () {
+            var headerRect, headerBuffer, header, metadataRect, metadataBuffer, metadata;
+            return videoUtils_generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (inServerSideRenderingEnvironment()) {
+                            throw errorNotSupportedOnPlatform;
+                        }
+                        if (texture.format !== 'NV12') {
+                            this.notifyError(VideoFrameTransformErrors.UnsupportedVideoFramePixelFormat);
+                            throw new Error(VideoFrameTransformErrors.UnsupportedVideoFramePixelFormat);
+                        }
+                        headerRect = { x: 0, y: 0, width: texture.codedWidth, height: 2 };
+                        headerBuffer = new ArrayBuffer((headerRect.width * headerRect.height * 3) / 2);
+                        return [4 /*yield*/, texture.copyTo(headerBuffer, { rect: headerRect })];
+                    case 1:
+                        _a.sent();
+                        header = new OneTextureHeader(headerBuffer, this.notifyError);
+                        metadataRect = {
+                            x: 0,
+                            y: header.multiStreamHeaderRowOffset,
+                            width: texture.codedWidth,
+                            height: texture.codedHeight - header.multiStreamHeaderRowOffset,
+                        };
+                        metadataBuffer = new ArrayBuffer((metadataRect.width * metadataRect.height * 3) / 2);
+                        return [4 /*yield*/, texture.copyTo(metadataBuffer, { rect: metadataRect })];
+                    case 2:
+                        _a.sent();
+                        metadata = new OneTextureMetadata(metadataBuffer, header.multiStreamCount);
+                        return [2 /*return*/, {
+                                videoFrame: new VideoFrame(texture, {
+                                    timestamp: texture.timestamp,
+                                    visibleRect: {
+                                        x: 0,
+                                        y: header.frameRowOffset,
+                                        width: header.frameWidth,
+                                        height: header.frameHeight,
+                                    },
+                                }),
+                                metadata: {
+                                    audioInferenceResult: this.shouldDiscardAudioInferenceResult ? undefined : metadata.audioInferenceResult,
+                                },
+                            }];
+                }
+            });
+        }); };
+        registerHandler('video.mediaStream.audioInferenceDiscardStatusChange', function (_a) {
+            var discardAudioInferenceResult = _a.discardAudioInferenceResult;
+            _this.shouldDiscardAudioInferenceResult = discardAudioInferenceResult;
+        });
+    }
+    return TransformerWithMetadata;
+}());
 /**
  * @hidden
  */
@@ -8001,11 +8276,11 @@ function createEffectParameterChangeCallback(callback) {
     return function (effectId, effectParam) {
         callback(effectId, effectParam)
             .then(function () {
-            sendMessageToParent('video.videoEffectReadiness', [true, effectId]);
+            sendMessageToParent('video.videoEffectReadiness', [true, effectId, undefined, effectParam]);
         })
             .catch(function (reason) {
             var validReason = reason in video.EffectFailureReason ? reason : video.EffectFailureReason.InitializationFailure;
-            sendMessageToParent('video.videoEffectReadiness', [false, effectId, validReason]);
+            sendMessageToParent('video.videoEffectReadiness', [false, effectId, validReason, effectParam]);
         });
     };
 }
@@ -9571,6 +9846,423 @@ function ensureSupported() {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-browser/regex.js
+/* harmony default export */ const regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-browser/validate.js
+
+
+function validate_validate(uuid) {
+  return typeof uuid === 'string' && regex.test(uuid);
+}
+
+/* harmony default export */ const esm_browser_validate = (validate_validate);
+;// CONCATENATED MODULE: ./src/internal/marketplaceUtils.ts
+var marketplaceUtils_assign = (undefined && undefined.__assign) || function () {
+    marketplaceUtils_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return marketplaceUtils_assign.apply(this, arguments);
+};
+var marketplaceUtils_rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+
+/**
+ * @hidden
+ * deserialize the cart data:
+ * - convert url properties from string to URL
+ * @param cartItems The cart items
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function deserializeCart(cartData) {
+    try {
+        cartData.cartItems = deserializeCartItems(cartData.cartItems);
+        return cartData;
+    }
+    catch (e) {
+        throw new Error('Error deserializing cart');
+    }
+}
+/**
+ * @hidden
+ * deserialize the cart items:
+ * - convert url properties from string to URL
+ * @param cartItems The cart items
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function deserializeCartItems(cartItemsData) {
+    return cartItemsData.map(function (cartItem) {
+        if (cartItem.imageURL) {
+            var url = new URL(cartItem.imageURL);
+            cartItem.imageURL = url;
+        }
+        if (cartItem.accessories) {
+            cartItem.accessories = deserializeCartItems(cartItem.accessories);
+        }
+        return cartItem;
+    });
+}
+/**
+ * @hidden
+ * serialize the cart items:
+ * - make URL properties to string
+ * @param cartItems The cart items
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+var serializeCartItems = function (cartItems) {
+    try {
+        return cartItems.map(function (cartItem) {
+            var imageURL = cartItem.imageURL, accessories = cartItem.accessories, rest = marketplaceUtils_rest(cartItem, ["imageURL", "accessories"]);
+            var cartItemsData = marketplaceUtils_assign({}, rest);
+            if (imageURL) {
+                cartItemsData.imageURL = imageURL.href;
+            }
+            if (accessories) {
+                cartItemsData.accessories = serializeCartItems(accessories);
+            }
+            return cartItemsData;
+        });
+    }
+    catch (e) {
+        throw new Error('Error serializing cart items');
+    }
+};
+/**
+ * @hidden
+ * Validate the cart item properties are valid
+ * @param cartItems The cart items
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateCartItems(cartItems) {
+    if (!Array.isArray(cartItems) || cartItems.length === 0) {
+        throw new Error('cartItems must be a non-empty array');
+    }
+    for (var _i = 0, cartItems_1 = cartItems; _i < cartItems_1.length; _i++) {
+        var cartItem = cartItems_1[_i];
+        validateBasicCartItem(cartItem);
+        validateAccessoryItems(cartItem.accessories);
+    }
+}
+/**
+ * @hidden
+ * Validate accessories
+ * @param accessoryItems The accessories to be validated
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateAccessoryItems(accessoryItems) {
+    if (accessoryItems === null || accessoryItems === undefined) {
+        return;
+    }
+    if (!Array.isArray(accessoryItems) || accessoryItems.length === 0) {
+        throw new Error('CartItem.accessories must be a non-empty array');
+    }
+    for (var _i = 0, accessoryItems_1 = accessoryItems; _i < accessoryItems_1.length; _i++) {
+        var accessoryItem = accessoryItems_1[_i];
+        if (accessoryItem['accessories']) {
+            throw new Error('Item in CartItem.accessories cannot have accessories');
+        }
+        validateBasicCartItem(accessoryItem);
+    }
+}
+/**
+ * @hidden
+ * Validate the basic cart item properties are valid
+ * @param basicCartItem The basic cart item
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateBasicCartItem(basicCartItem) {
+    if (!basicCartItem.id) {
+        throw new Error('cartItem.id must not be empty');
+    }
+    if (!basicCartItem.name) {
+        throw new Error('cartItem.name must not be empty');
+    }
+    validatePrice(basicCartItem.price);
+    validateQuantity(basicCartItem.quantity);
+}
+/**
+ * @hidden
+ * Validate the id is valid
+ * @param id A uuid string
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateUuid(id) {
+    if (id === undefined || id === null) {
+        return;
+    }
+    if (!id) {
+        throw new Error('id must not be empty');
+    }
+    if (esm_browser_validate(id) === false) {
+        throw new Error('id must be a valid UUID');
+    }
+}
+/**
+ * @hidden
+ * Validate the cart item properties are valid
+ * @param price The price to be validated
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validatePrice(price) {
+    if (typeof price !== 'number' || price < 0) {
+        throw new Error("price ".concat(price, " must be a number not less than 0"));
+    }
+    if (parseFloat(price.toFixed(3)) !== price) {
+        throw new Error("price ".concat(price, " must have at most 3 decimal places"));
+    }
+}
+/**
+ * @hidden
+ * Validate quantity
+ * @param quantity The quantity to be validated
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateQuantity(quantity) {
+    if (typeof quantity !== 'number' || quantity <= 0 || parseInt(quantity.toString()) !== quantity) {
+        throw new Error("quantity ".concat(quantity, " must be an integer greater than 0"));
+    }
+}
+/**
+ * @hidden
+ * Validate cart status
+ * @param cartStatus The cartStatus to be validated
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateCartStatus(cartStatus) {
+    if (!Object.values(marketplace.CartStatus).includes(cartStatus)) {
+        throw new Error("cartStatus ".concat(cartStatus, " is not valid"));
+    }
+}
+
+;// CONCATENATED MODULE: ./src/public/marketplace.ts
+var marketplace_assign = (undefined && undefined.__assign) || function () {
+    marketplace_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return marketplace_assign.apply(this, arguments);
+};
+
+
+
+
+
+/**
+ * @hidden
+ * Namespace for an app to support a checkout flow by interacting with the marketplace cart in the host.
+ * @beta
+ */
+var marketplace;
+(function (marketplace) {
+    /**
+     * @hidden
+     * the version of the current cart interface
+     * which is forced to send to the host in the calls.
+     * @internal
+     * Limited to Microsoft-internal use
+     * @beta
+     */
+    marketplace.cartVersion = {
+        /**
+         * @hidden
+         * Represents the major version of the current cart interface,
+         * it is increased when incompatible interface update happens.
+         */
+        majorVersion: 1,
+        /**
+         * @hidden
+         * The minor version of the current cart interface, which is compatible
+         * with the previous minor version in the same major version.
+         */
+        minorVersion: 1,
+    };
+    /**
+     * @hidden
+     * Represents the persona creating the cart.
+     * @beta
+     */
+    var Intent;
+    (function (Intent) {
+        /**
+         * @hidden
+         * The cart is created by admin of an organization in Teams Admin Center.
+         */
+        Intent["TACAdminUser"] = "TACAdminUser";
+        /**
+         * @hidden
+         * The cart is created by admin of an organization in Teams.
+         */
+        Intent["TeamsAdminUser"] = "TeamsAdminUser";
+        /**
+         * @hidden
+         * The cart is created by end user of an organization in Teams.
+         */
+        Intent["TeamsEndUser"] = "TeamsEndUser";
+    })(Intent = marketplace.Intent || (marketplace.Intent = {}));
+    /**
+     * @hidden
+     * Represents the status of the cart.
+     * @beta
+     */
+    var CartStatus;
+    (function (CartStatus) {
+        /**
+         * @hidden
+         * Cart is created but not checked out yet.
+         */
+        CartStatus["Open"] = "Open";
+        /**
+         * @hidden
+         * Cart is checked out but not completed yet.
+         */
+        CartStatus["Processing"] = "Processing";
+        /**
+         * @hidden
+         * Indicate checking out is completed and the host should
+         * return a new cart in the next getCart call.
+         */
+        CartStatus["Processed"] = "Processed";
+        /**
+         * @hidden
+         * Indicate checking out process is manually cancelled by the user
+         */
+        CartStatus["Closed"] = "Closed";
+        /**
+         * @hidden
+         * Indicate checking out is failed and the host should
+         * return a new cart in the next getCart call.
+         */
+        CartStatus["Error"] = "Error";
+    })(CartStatus = marketplace.CartStatus || (marketplace.CartStatus = {}));
+    /**
+     * @hidden
+     * Get the cart object owned by the host to checkout.
+     * @returns A promise of the cart object in the cartVersion.
+     * @beta
+     */
+    function getCart() {
+        ensureInitialized(runtime, FrameContexts.content, FrameContexts.task);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        return sendAndHandleSdkError('marketplace.getCart', marketplace.cartVersion).then(deserializeCart);
+    }
+    marketplace.getCart = getCart;
+    /**
+     * @hidden
+     * Add or update cart items in the cart owned by the host.
+     * @param addOrUpdateCartItemsParams Represents the parameters to update the cart items.
+     * @returns A promise of the updated cart object in the cartVersion.
+     * @beta
+     */
+    function addOrUpdateCartItems(addOrUpdateCartItemsParams) {
+        ensureInitialized(runtime, FrameContexts.content, FrameContexts.task);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        if (!addOrUpdateCartItemsParams) {
+            throw new Error('addOrUpdateCartItemsParams must be provided');
+        }
+        validateUuid(addOrUpdateCartItemsParams === null || addOrUpdateCartItemsParams === void 0 ? void 0 : addOrUpdateCartItemsParams.cartId);
+        validateCartItems(addOrUpdateCartItemsParams === null || addOrUpdateCartItemsParams === void 0 ? void 0 : addOrUpdateCartItemsParams.cartItems);
+        return sendAndHandleSdkError('marketplace.addOrUpdateCartItems', marketplace_assign(marketplace_assign({}, addOrUpdateCartItemsParams), { cartItems: serializeCartItems(addOrUpdateCartItemsParams.cartItems), cartVersion: marketplace.cartVersion })).then(deserializeCart);
+    }
+    marketplace.addOrUpdateCartItems = addOrUpdateCartItems;
+    /**
+     * @hidden
+     * Remove cart items from the cart owned by the host.
+     * @param removeCartItemsParams The parameters to remove the cart items.
+     * @returns A promise of the updated cart object in the cartVersion.
+     * @beta
+     */
+    function removeCartItems(removeCartItemsParams) {
+        ensureInitialized(runtime, FrameContexts.content, FrameContexts.task);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        if (!removeCartItemsParams) {
+            throw new Error('removeCartItemsParams must be provided');
+        }
+        validateUuid(removeCartItemsParams === null || removeCartItemsParams === void 0 ? void 0 : removeCartItemsParams.cartId);
+        if (!Array.isArray(removeCartItemsParams === null || removeCartItemsParams === void 0 ? void 0 : removeCartItemsParams.cartItemIds) || (removeCartItemsParams === null || removeCartItemsParams === void 0 ? void 0 : removeCartItemsParams.cartItemIds.length) === 0) {
+            throw new Error('cartItemIds must be a non-empty array');
+        }
+        return sendAndHandleSdkError('marketplace.removeCartItems', marketplace_assign(marketplace_assign({}, removeCartItemsParams), { cartVersion: marketplace.cartVersion })).then(deserializeCart);
+    }
+    marketplace.removeCartItems = removeCartItems;
+    /**
+     * @hidden
+     * Update cart status in the cart owned by the host.
+     * @param updateCartStatusParams The parameters to update the cart status.
+     * @returns A promise of the updated cart object in the cartVersion.
+     * @beta
+     */
+    function updateCartStatus(updateCartStatusParams) {
+        ensureInitialized(runtime, FrameContexts.content, FrameContexts.task);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        if (!updateCartStatusParams) {
+            throw new Error('updateCartStatusParams must be provided');
+        }
+        validateUuid(updateCartStatusParams === null || updateCartStatusParams === void 0 ? void 0 : updateCartStatusParams.cartId);
+        validateCartStatus(updateCartStatusParams === null || updateCartStatusParams === void 0 ? void 0 : updateCartStatusParams.cartStatus);
+        return sendAndHandleSdkError('marketplace.updateCartStatus', marketplace_assign(marketplace_assign({}, updateCartStatusParams), { cartVersion: marketplace.cartVersion })).then(deserializeCart);
+    }
+    marketplace.updateCartStatus = updateCartStatus;
+    /**
+     * @hidden
+     * Checks if the marketplace capability is supported by the host.
+     * @returns Boolean to represent whether the marketplace capability is supported.
+     * @throws Error if {@linkcode app.initialize} has not successfully completed.
+     * @beta
+     */
+    function isSupported() {
+        return ensureInitialized(runtime) && runtime.supports.marketplace ? true : false;
+    }
+    marketplace.isSupported = isSupported;
+})(marketplace || (marketplace = {}));
+
 ;// CONCATENATED MODULE: ./src/public/index.ts
 
 
@@ -9606,6 +10298,7 @@ function ensureSupported() {
 
 
 
+
 
 
 
@@ -10841,6 +11534,43 @@ var teams;
 })(teams || (teams = {}));
 
 ;// CONCATENATED MODULE: ./src/private/videoEx.ts
+var videoEx_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var videoEx_generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+
 
 
 
@@ -10876,31 +11606,74 @@ var videoEx;
      * Register to process video frames
      * @beta
      *
-     * @param frameCallback - The callback to invoke when registerForVideoFrame has completed
-     * @param config - VideoFrameConfig to customize generated video frame parameters
+     * @param parameters - Callbacks and configuration to process the video frames. A host may support either {@link VideoFrameHandler} or {@link VideoBufferHandler}, but not both.
+     * To ensure the video effect works on all supported hosts, the video app must provide both {@link VideoFrameHandler} and {@link VideoBufferHandler}.
+     * The host will choose the appropriate callback based on the host's capability.
      *
      * @internal
      * Limited to Microsoft-internal use
      */
     function registerForVideoFrame(parameters) {
-        ensureInitialized(runtime, FrameContexts.sidePanel);
+        var _this = this;
+        var _a, _b;
         if (!isSupported()) {
             throw errorNotSupportedOnPlatform;
         }
-        if (!parameters.videoBufferHandler) {
-            throw new Error('parameters.videoBufferHandler must be provided');
+        if (!parameters.videoFrameHandler || !parameters.videoBufferHandler) {
+            throw new Error('Both videoFrameHandler and videoBufferHandler must be provided');
         }
-        registerHandler('video.newVideoFrame', function (videoBufferData) {
-            if (videoBufferData) {
-                var timestamp_1 = videoBufferData.timestamp;
-                parameters.videoBufferHandler(videoBufferData, function () {
-                    notifyVideoFrameProcessed(timestamp_1);
-                }, notifyError);
+        if (ensureInitialized(runtime, FrameContexts.sidePanel)) {
+            if ((_a = runtime.supports.video) === null || _a === void 0 ? void 0 : _a.mediaStream) {
+                registerHandler('video.startVideoExtensibilityVideoStream', function (mediaStreamInfo) { return videoEx_awaiter(_this, void 0, void 0, function () {
+                    var streamId, metadataInTexture, generator, _a;
+                    var _b, _c;
+                    return videoEx_generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                streamId = mediaStreamInfo.streamId, metadataInTexture = mediaStreamInfo.metadataInTexture;
+                                if (!metadataInTexture) return [3 /*break*/, 2];
+                                return [4 /*yield*/, processMediaStreamWithMetadata(streamId, parameters.videoFrameHandler, notifyError)];
+                            case 1:
+                                _a = _d.sent();
+                                return [3 /*break*/, 4];
+                            case 2: return [4 /*yield*/, processMediaStream(streamId, parameters.videoFrameHandler, notifyError)];
+                            case 3:
+                                _a = _d.sent();
+                                _d.label = 4;
+                            case 4:
+                                generator = _a;
+                                // register the video track with processed frames back to the stream
+                                !inServerSideRenderingEnvironment() &&
+                                    ((_c = (_b = window['chrome']) === null || _b === void 0 ? void 0 : _b.webview) === null || _c === void 0 ? void 0 : _c.registerTextureStream(streamId, generator));
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, false);
+                sendMessageToParent('video.mediaStream.registerForVideoFrame', [parameters.config]);
+            }
+            else if ((_b = runtime.supports.video) === null || _b === void 0 ? void 0 : _b.sharedFrame) {
+                registerHandler('video.newVideoFrame', function (videoBufferData) {
+                    if (videoBufferData) {
+                        var timestamp_1 = videoBufferData.timestamp;
+                        parameters.videoBufferHandler(normalizedVideoBufferData(videoBufferData), function () {
+                            notifyVideoFrameProcessed(timestamp_1);
+                        }, notifyError);
+                    }
+                }, false);
+                sendMessageToParent('video.registerForVideoFrame', [parameters.config]);
             }
-        }, false);
-        sendMessageToParent('video.registerForVideoFrame', [parameters.config]);
+            else {
+                // should not happen if isSupported() is true
+                throw errorNotSupportedOnPlatform;
+            }
+        }
     }
     videoEx.registerForVideoFrame = registerForVideoFrame;
+    function normalizedVideoBufferData(videoBufferData) {
+        videoBufferData['videoFrameBuffer'] = videoBufferData['videoFrameBuffer'] || videoBufferData['data'];
+        delete videoBufferData['data'];
+        return videoBufferData;
+    }
     /**
      * @hidden
      * Video extension should call this to notify host that the current selected effect parameter changed.