@snap/camera-kit 0.7.0

package/lib/benchmark/benchmarkGflops.js

@@ -0,0 +1,129 @@
+import { __awaiter } from "tslib";
+import { createFramebuffer, createProgram, createTexture, promiseSync, setUniform1i, setUniform4f } from "./webglUtils";
+const vertexSource = `#version 300 es
+
+precision mediump float;
+precision mediump int;
+
+in vec2 pos;
+
+void main() {
+    gl_Position = vec4(pos, 0.0, 1.0);
+}
+`;
+const fragmentSource = `#version 300 es
+
+precision mediump float;
+precision mediump int;
+
+uniform int LOOP_COUNT;
+uniform vec4 v0;
+uniform vec4 v1;
+uniform vec4 v2;
+
+out vec4 fragColor;
+
+#define REPEAT_2(x) x; x
+#define REPEAT_4(x) REPEAT_2(x); REPEAT_2(x)
+#define REPEAT_8(x) REPEAT_4(x); REPEAT_4(x)
+#define REPEAT_16(x) REPEAT_8(x); REPEAT_8(x)
+#define REPEAT_32(x) REPEAT_16(x); REPEAT_16(x)
+
+void main() {
+    vec4 r = v2;
+    for (int i = 0; i < LOOP_COUNT; i++) {
+        REPEAT_32(r = r * v1 + v0);
+    }
+    fragColor = r;
+}
+`;
+const width = 1024;
+const height = 1024;
+const budgetMs = 300;
+const maxLoopCount = 1000;
+function prepareBenchmark(gl) {
+    const texture = createTexture(gl, width, height);
+    const framebuffer = createFramebuffer(gl, texture);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    const buffer = gl.createBuffer();
+    if (!buffer) {
+        throw new Error("Failed to create WebGLBuffer.");
+    }
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, 1, -1, -1, 1, -1, 1, 1]), gl.STATIC_DRAW);
+    gl.viewport(0, 0, width, height);
+    gl.disable(gl.CULL_FACE);
+    gl.disable(gl.DEPTH_TEST);
+    const program = createProgram(gl, vertexSource, fragmentSource);
+    gl.useProgram(program);
+    const posLocation = gl.getAttribLocation(program, "pos");
+    gl.enableVertexAttribArray(posLocation);
+    gl.vertexAttribPointer(posLocation, 2, gl.FLOAT, false, 0, 0);
+    setUniform4f(gl, program, "v0", [1.15, 1.23, 1.47, 1.84]);
+    setUniform4f(gl, program, "v1", [1.65, 1.22, 1.69, 1.04]);
+    setUniform4f(gl, program, "v2", [1.05, 1.3, 1.55, 1.23]);
+    return {
+        program,
+        cleanupBenchmark: () => {
+            gl.deleteProgram(program);
+            gl.deleteBuffer(buffer);
+            gl.deleteFramebuffer(framebuffer);
+            gl.deleteTexture(texture);
+        },
+    };
+}
+function runBenchmark(gl, program) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield promiseSync(gl);
+        const start = performance.now();
+        const flops = [];
+        let loopCount = 20;
+        while (true) {
+            setUniform1i(gl, program, "LOOP_COUNT", loopCount);
+            const iterationStart = performance.now();
+            gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+            yield promiseSync(gl);
+            const iterationEnd = performance.now();
+            const duration = iterationEnd - iterationStart;
+            flops.push(loopCount / duration);
+            const remainingBudgetMs = budgetMs - (iterationEnd - start);
+            if (remainingBudgetMs < 0)
+                break;
+            if (loopCount < maxLoopCount) {
+                loopCount += remainingBudgetMs < duration ? 10 : (0.6 * loopCount * remainingBudgetMs) / duration;
+            }
+        }
+        const maxFlops = Math.max(...flops) * (8 * 32) * width * height;
+        return maxFlops / 1e6;
+    });
+}
+/**
+ * These are obtained from historical performance data gathered from end-user devices. Keys are gflops, values are the
+ * corresponding performance rating.
+ *
+ * To compute the performance rating given a gflops value, find the nearest key in this map and look up the rating.
+ */
+export const gflopsClusterCenters = new Map([
+    [34, 1],
+    [134, 2],
+    [385, 3],
+    [783, 4],
+    [1484, 5],
+    [2313, 6],
+]);
+/**
+ * This benchmark is the same that's run on non-web (e.g. native mobile) platforms, and produces results that can be
+ * compared to those gathered on those platforms – this allows us to cluster results and determine a performance rating
+ * based on historical data gathered elsewhere.
+ *
+ * @internal
+ */
+export function benchmarkGflops(gl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { program, cleanupBenchmark } = prepareBenchmark(gl);
+        const gflops = yield runBenchmark(gl, program);
+        cleanupBenchmark();
+        return { name: "gflops", value: gflops };
+    });
+}
+//# sourceMappingURL=benchmarkGflops.js.map

package/lib/benchmark/benchmarkGflops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkGflops.js","sourceRoot":"","sources":["../../src/benchmark/benchmarkGflops.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAExH,MAAM,YAAY,GAAG;;;;;;;;;;CAUpB,CAAC;AAEF,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBtB,CAAC;AAEF,MAAM,KAAK,GAAG,IAAI,CAAC;AACnB,MAAM,MAAM,GAAG,IAAI,CAAC;AACpB,MAAM,QAAQ,GAAG,GAAG,CAAC;AACrB,MAAM,YAAY,GAAG,IAAI,CAAC;AAE1B,SAAS,gBAAgB,CAAC,EAA0B;IAChD,MAAM,OAAO,GAAG,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IACjD,MAAM,WAAW,GAAG,iBAAiB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACnD,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAEhD,MAAM,MAAM,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC;IACjC,IAAI,CAAC,MAAM,EAAE;QACT,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;KACpD;IACD,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IACvC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC;IAE/F,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IACjC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;IACzB,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;IAE1B,MAAM,OAAO,GAAG,aAAa,CAAC,EAAE,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;IAChE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAEvB,MAAM,WAAW,GAAG,EAAE,CAAC,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACzD,EAAE,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;IACxC,EAAE,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE9D,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAC1D,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAC1D,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAEzD,OAAO;QACH,OAAO;QACP,gBAAgB,EAAE,GAAG,EAAE;YACnB,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAC1B,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YACxB,EAAE,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;YAClC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;KACJ,CAAC;AACN,CAAC;AAED,SAAe,YAAY,CAAC,EAA0B,EAAE,OAAqB;;QACzE,MAAM,WAAW,CAAC,EAAE,CAAC,CAAC;QAEtB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,MAAM,KAAK,GAAa,EAAE,CAAC;QAE3B,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,OAAO,IAAI,EAAE;YACT,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;YAEnD,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YAEzC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACrC,MAAM,WAAW,CAAC,EAAE,CAAC,CAAC;YAEtB,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YACvC,MAAM,QAAQ,GAAG,YAAY,GAAG,cAAc,CAAC;YAC/C,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC;YAEjC,MAAM,iBAAiB,GAAG,QAAQ,GAAG,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC;YAC5D,IAAI,iBAAiB,GAAG,CAAC;gBAAE,MAAM;YAEjC,IAAI,SAAS,GAAG,YAAY,EAAE;gBAC1B,SAAS,IAAI,iBAAiB,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,SAAS,GAAG,iBAAiB,CAAC,GAAG,QAAQ,CAAC;aACrG;SACJ;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,KAAK,GAAG,MAAM,CAAC;QAChE,OAAO,QAAQ,GAAG,GAAG,CAAC;IAC1B,CAAC;CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAiC;IACxE,CAAC,EAAE,EAAE,CAAC,CAAC;IACP,CAAC,GAAG,EAAE,CAAC,CAAC;IACR,CAAC,GAAG,EAAE,CAAC,CAAC;IACR,CAAC,GAAG,EAAE,CAAC,CAAC;IACR,CAAC,IAAI,EAAE,CAAC,CAAC;IACT,CAAC,IAAI,EAAE,CAAC,CAAC;CACZ,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAgB,eAAe,CAAC,EAA0B;;QAC5D,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,CAAC,EAAE,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC/C,gBAAgB,EAAE,CAAC;QACnB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC7C,CAAC;CAAA","sourcesContent":["import { BenchmarkResult, LensPerformanceCluster } from \"./estimateLensPerformanceCluster\";\nimport { createFramebuffer, createProgram, createTexture, promiseSync, setUniform1i, setUniform4f } from \"./webglUtils\";\n\nconst vertexSource = `#version 300 es\n\nprecision mediump float;\nprecision mediump int;\n\nin vec2 pos;\n\nvoid main() {\n    gl_Position = vec4(pos, 0.0, 1.0);\n}\n`;\n\nconst fragmentSource = `#version 300 es\n\nprecision mediump float;\nprecision mediump int;\n\nuniform int LOOP_COUNT;\nuniform vec4 v0;\nuniform vec4 v1;\nuniform vec4 v2;\n\nout vec4 fragColor;\n\n#define REPEAT_2(x) x; x\n#define REPEAT_4(x) REPEAT_2(x); REPEAT_2(x)\n#define REPEAT_8(x) REPEAT_4(x); REPEAT_4(x)\n#define REPEAT_16(x) REPEAT_8(x); REPEAT_8(x)\n#define REPEAT_32(x) REPEAT_16(x); REPEAT_16(x)\n\nvoid main() {\n    vec4 r = v2;\n    for (int i = 0; i < LOOP_COUNT; i++) {\n        REPEAT_32(r = r * v1 + v0);\n    }\n    fragColor = r;\n}\n`;\n\nconst width = 1024;\nconst height = 1024;\nconst budgetMs = 300;\nconst maxLoopCount = 1000;\n\nfunction prepareBenchmark(gl: WebGL2RenderingContext): { program: WebGLProgram; cleanupBenchmark: () => void } {\n    const texture = createTexture(gl, width, height);\n    const framebuffer = createFramebuffer(gl, texture);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n\n    const buffer = gl.createBuffer();\n    if (!buffer) {\n        throw new Error(\"Failed to create WebGLBuffer.\");\n    }\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, 1, -1, -1, 1, -1, 1, 1]), gl.STATIC_DRAW);\n\n    gl.viewport(0, 0, width, height);\n    gl.disable(gl.CULL_FACE);\n    gl.disable(gl.DEPTH_TEST);\n\n    const program = createProgram(gl, vertexSource, fragmentSource);\n    gl.useProgram(program);\n\n    const posLocation = gl.getAttribLocation(program, \"pos\");\n    gl.enableVertexAttribArray(posLocation);\n    gl.vertexAttribPointer(posLocation, 2, gl.FLOAT, false, 0, 0);\n\n    setUniform4f(gl, program, \"v0\", [1.15, 1.23, 1.47, 1.84]);\n    setUniform4f(gl, program, \"v1\", [1.65, 1.22, 1.69, 1.04]);\n    setUniform4f(gl, program, \"v2\", [1.05, 1.3, 1.55, 1.23]);\n\n    return {\n        program,\n        cleanupBenchmark: () => {\n            gl.deleteProgram(program);\n            gl.deleteBuffer(buffer);\n            gl.deleteFramebuffer(framebuffer);\n            gl.deleteTexture(texture);\n        },\n    };\n}\n\nasync function runBenchmark(gl: WebGL2RenderingContext, program: WebGLProgram): Promise<number> {\n    await promiseSync(gl);\n\n    const start = performance.now();\n    const flops: number[] = [];\n\n    let loopCount = 20;\n    while (true) {\n        setUniform1i(gl, program, \"LOOP_COUNT\", loopCount);\n\n        const iterationStart = performance.now();\n\n        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);\n        await promiseSync(gl);\n\n        const iterationEnd = performance.now();\n        const duration = iterationEnd - iterationStart;\n        flops.push(loopCount / duration);\n\n        const remainingBudgetMs = budgetMs - (iterationEnd - start);\n        if (remainingBudgetMs < 0) break;\n\n        if (loopCount < maxLoopCount) {\n            loopCount += remainingBudgetMs < duration ? 10 : (0.6 * loopCount * remainingBudgetMs) / duration;\n        }\n    }\n\n    const maxFlops = Math.max(...flops) * (8 * 32) * width * height;\n    return maxFlops / 1e6;\n}\n\n/**\n * These are obtained from historical performance data gathered from end-user devices. Keys are gflops, values are the\n * corresponding performance rating.\n *\n * To compute the performance rating given a gflops value, find the nearest key in this map and look up the rating.\n */\nexport const gflopsClusterCenters = new Map<number, LensPerformanceCluster>([\n    [34, 1],\n    [134, 2],\n    [385, 3],\n    [783, 4],\n    [1484, 5],\n    [2313, 6],\n]);\n\n/**\n * This benchmark is the same that's run on non-web (e.g. native mobile) platforms, and produces results that can be\n * compared to those gathered on those platforms – this allows us to cluster results and determine a performance rating\n * based on historical data gathered elsewhere.\n *\n * @internal\n */\nexport async function benchmarkGflops(gl: WebGL2RenderingContext): Promise<BenchmarkResult> {\n    const { program, cleanupBenchmark } = prepareBenchmark(gl);\n    const gflops = await runBenchmark(gl, program);\n    cleanupBenchmark();\n    return { name: \"gflops\", value: gflops };\n}\n"]}

package/lib/benchmark/estimateLensPerformanceCluster.d.ts

@@ -0,0 +1,33 @@
+/** @category Bootstrapping and Configuration */
+export declare type LensPerformanceCluster = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** @internal */
+export declare type BenchmarkResult = {
+    name: string;
+    value: number;
+};
+/**
+ * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are
+ * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on
+ * low-performance devices).
+ *
+ * The cluster value will be an integer from 1-6 which classifies expected lens performance, where 6 is the highest-
+ * performing cluster and 1 the lowest.
+ *
+ * All the raw benchmark results used to estimate the performance cluster are also included for reporting purposes.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export interface EstimatedLensPerformance {
+    cluster: LensPerformanceCluster;
+    benchmarks: BenchmarkResult[];
+    webglRendererInfo: string;
+}
+/**
+ * Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)
+ * which the CameraKit SDK can use to optimize certain lenses.
+ *
+ * @returns A rating from 1-6, indicating expected Lens performance.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function estimateLensPerformance(): Promise<EstimatedLensPerformance>;

package/lib/benchmark/estimateLensPerformanceCluster.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import { benchmarkError } from "../namedErrors";
+import { gflopsClusterCenters, benchmarkGflops } from "./benchmarkGflops";
+const findNearest = (n, arr) => arr.reduce((a, b) => (Math.abs(a - n) <= Math.abs(b - n) ? a : b));
+const webglContextAttributes = {
+    alpha: false,
+    antialias: false,
+    premultipliedAlpha: false,
+    preserveDrawingBuffer: false,
+    depth: false,
+    stencil: false,
+    failIfMajorPerformanceCaveat: false,
+    powerPreference: "high-performance",
+};
+/**
+ * Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)
+ * which the CameraKit SDK can use to optimize certain lenses.
+ *
+ * @returns A rating from 1-6, indicating expected Lens performance.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export function estimateLensPerformance() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        // Prepare performance measurement.
+        const canvas = document.createElement("canvas");
+        const gl = canvas.getContext("webgl2", webglContextAttributes);
+        if (!gl)
+            throw benchmarkError("WebGL2 is required to compute performance, but it is not supported.");
+        const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+        const webglRendererInfo = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : "unknown";
+        // Measure performance (just GFLOPS for now, but could add more benchmarks in the future).
+        const gflops = yield benchmarkGflops(gl);
+        // Combine performance results and compute a performance rating. Right now we just run a single benchmark, so this
+        // is pretty trivial.
+        const nearestGflopsClusterCenter = findNearest(gflops.value, Array.from(gflopsClusterCenters.keys()));
+        // This should always find a value, but just in case something strange happens inside `findNearest`, we'll default
+        // to zero (instead of asserting .get() will always be defined).
+        const gflopsCluster = (_a = gflopsClusterCenters.get(nearestGflopsClusterCenter)) !== null && _a !== void 0 ? _a : 0;
+        return {
+            cluster: gflopsCluster,
+            benchmarks: [gflops],
+            webglRendererInfo,
+        };
+    });
+}
+//# sourceMappingURL=estimateLensPerformanceCluster.js.map

package/lib/benchmark/estimateLensPerformanceCluster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimateLensPerformanceCluster.js","sourceRoot":"","sources":["../../src/benchmark/estimateLensPerformanceCluster.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,GAAG,CAAC,CAAS,EAAE,GAAa,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAErH,MAAM,sBAAsB,GAA2B;IACnD,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,KAAK;IAChB,kBAAkB,EAAE,KAAK;IACzB,qBAAqB,EAAE,KAAK;IAC5B,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,KAAK;IACd,4BAA4B,EAAE,KAAK;IACnC,eAAe,EAAE,kBAAkB;CACtC,CAAC;AA0BF;;;;;;;GAOG;AACH,MAAM,UAAgB,uBAAuB;;;QACzC,mCAAmC;QACnC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE;YAAE,MAAM,cAAc,CAAC,qEAAqE,CAAC,CAAC;QAErG,MAAM,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC;QAC/D,MAAM,iBAAiB,GAAG,SAAS,CAAC,CAAC,CAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,uBAAuB,CAAY,CAAC,CAAC,CAAC,SAAS,CAAC;QAEjH,0FAA0F;QAC1F,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,CAAC,CAAC;QAEzC,kHAAkH;QAClH,qBAAqB;QACrB,MAAM,0BAA0B,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAEtG,kHAAkH;QAClH,gEAAgE;QAChE,MAAM,aAAa,GAAG,MAAA,oBAAoB,CAAC,GAAG,CAAC,0BAA0B,CAAC,mCAAI,CAAC,CAAC;QAEhF,OAAO;YACH,OAAO,EAAE,aAAa;YACtB,UAAU,EAAE,CAAC,MAAM,CAAC;YACpB,iBAAiB;SACpB,CAAC;;CACL","sourcesContent":["import { benchmarkError } from \"../namedErrors\";\nimport { gflopsClusterCenters, benchmarkGflops } from \"./benchmarkGflops\";\n\nconst findNearest = (n: number, arr: number[]) => arr.reduce((a, b) => (Math.abs(a - n) <= Math.abs(b - n) ? a : b));\n\nconst webglContextAttributes: WebGLContextAttributes = {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: false,\n    powerPreference: \"high-performance\",\n};\n\n/** @category Bootstrapping and Configuration */\nexport type LensPerformanceCluster = 0 | 1 | 2 | 3 | 4 | 5 | 6;\n\n/** @internal */\nexport type BenchmarkResult = { name: string; value: number };\n\n/**\n * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are\n * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on\n * low-performance devices).\n *\n * The cluster value will be an integer from 1-6 which classifies expected lens performance, where 6 is the highest-\n * performing cluster and 1 the lowest.\n *\n * All the raw benchmark results used to estimate the performance cluster are also included for reporting purposes.\n *\n * @category Bootstrapping and Configuration\n */\nexport interface EstimatedLensPerformance {\n    cluster: LensPerformanceCluster;\n    benchmarks: BenchmarkResult[];\n    webglRendererInfo: string;\n}\n\n/**\n * Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)\n * which the CameraKit SDK can use to optimize certain lenses.\n *\n * @returns A rating from 1-6, indicating expected Lens performance.\n *\n * @category Bootstrapping and Configuration\n */\nexport async function estimateLensPerformance(): Promise<EstimatedLensPerformance> {\n    // Prepare performance measurement.\n    const canvas = document.createElement(\"canvas\");\n    const gl = canvas.getContext(\"webgl2\", webglContextAttributes);\n    if (!gl) throw benchmarkError(\"WebGL2 is required to compute performance, but it is not supported.\");\n\n    const debugInfo = gl.getExtension(\"WEBGL_debug_renderer_info\");\n    const webglRendererInfo = debugInfo ? (gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) as string) : \"unknown\";\n\n    // Measure performance (just GFLOPS for now, but could add more benchmarks in the future).\n    const gflops = await benchmarkGflops(gl);\n\n    // Combine performance results and compute a performance rating. Right now we just run a single benchmark, so this\n    // is pretty trivial.\n    const nearestGflopsClusterCenter = findNearest(gflops.value, Array.from(gflopsClusterCenters.keys()));\n\n    // This should always find a value, but just in case something strange happens inside `findNearest`, we'll default\n    // to zero (instead of asserting .get() will always be defined).\n    const gflopsCluster = gflopsClusterCenters.get(nearestGflopsClusterCenter) ?? 0;\n\n    return {\n        cluster: gflopsCluster,\n        benchmarks: [gflops],\n        webglRendererInfo,\n    };\n}\n"]}

package/lib/benchmark/webglUtils.d.ts

@@ -0,0 +1,7 @@
+export declare function createProgram(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string): WebGLProgram;
+export declare function createShader(gl: WebGL2RenderingContext, source: string, type: number): WebGLShader;
+export declare function createTexture(gl: WebGL2RenderingContext, width: number, height: number): WebGLTexture;
+export declare function createFramebuffer(gl: WebGL2RenderingContext, texture: WebGLTexture): WebGLFramebuffer;
+export declare function setUniform1i(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, data: number): void;
+export declare function setUniform4f(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, data: [number, number, number, number]): void;
+export declare function promiseSync(gl: WebGL2RenderingContext): Promise<void>;

package/lib/benchmark/webglUtils.js

@@ -0,0 +1,87 @@
+import { webGLError } from "../namedErrors";
+const webGLEntityCreationError = (name) => webGLError(`Could not create ${name}.`);
+export function createProgram(gl, vertexSource, fragmentSource) {
+    const vertexShader = createShader(gl, vertexSource, gl.VERTEX_SHADER);
+    const fragmentShader = createShader(gl, fragmentSource, gl.FRAGMENT_SHADER);
+    const program = gl.createProgram();
+    if (!program)
+        throw webGLEntityCreationError("WebGLProgram");
+    gl.attachShader(program, vertexShader);
+    gl.deleteShader(vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.deleteShader(fragmentShader);
+    gl.linkProgram(program);
+    const success = gl.getProgramParameter(program, gl.LINK_STATUS);
+    if (!success) {
+        const message = gl.getProgramInfoLog(program);
+        gl.deleteProgram(program);
+        throw webGLError(`WebGLProgram linking failed with status: ${message}`);
+    }
+    return program;
+}
+export function createShader(gl, source, type) {
+    const shader = gl.createShader(type);
+    if (!shader)
+        throw webGLEntityCreationError(`WebGLShader (type ${type})`);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    const success = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+    if (!success) {
+        const message = gl.getShaderInfoLog(shader);
+        gl.deleteShader(shader);
+        throw webGLError(`WebGLShader (type ${type}) compilation failed with status: ${message}`);
+    }
+    return shader;
+}
+export function createTexture(gl, width, height) {
+    const texture = gl.createTexture();
+    if (!texture)
+        throw webGLEntityCreationError("WebGLTexture");
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+    return texture;
+}
+export function createFramebuffer(gl, texture) {
+    const framebuffer = gl.createFramebuffer();
+    if (!framebuffer)
+        throw webGLEntityCreationError("WebGLFramebuffer");
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    return framebuffer;
+}
+export function setUniform1i(gl, program, name, data) {
+    gl.uniform1i(gl.getUniformLocation(program, name), data);
+}
+export function setUniform4f(gl, program, name, data) {
+    gl.uniform4f(gl.getUniformLocation(program, name), ...data);
+}
+export function promiseSync(gl) {
+    const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+    if (!sync)
+        throw webGLEntityCreationError("WebGLSync");
+    gl.flush();
+    return new Promise((resolve, reject) => {
+        const waitForSync = () => {
+            const glEnum = gl.clientWaitSync(sync, 0, 0);
+            switch (glEnum) {
+                case gl.TIMEOUT_EXPIRED:
+                    setTimeout(waitForSync);
+                    return;
+                case gl.WAIT_FAILED:
+                    gl.deleteSync(sync);
+                    return reject();
+                case gl.ALREADY_SIGNALED:
+                case gl.CONDITION_SATISFIED:
+                    gl.deleteSync(sync);
+                    return resolve();
+            }
+        };
+        waitForSync();
+    });
+}
+//# sourceMappingURL=webglUtils.js.map

package/lib/benchmark/webglUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webglUtils.js","sourceRoot":"","sources":["../../src/benchmark/webglUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { webGLError } from \"../namedErrors\";\n\nconst webGLEntityCreationError = (name: string) => webGLError(`Could not create ${name}.`);\n\nexport function createProgram(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string): WebGLProgram {\n    const vertexShader = createShader(gl, vertexSource, gl.VERTEX_SHADER);\n    const fragmentShader = createShader(gl, fragmentSource, gl.FRAGMENT_SHADER);\n    const program = gl.createProgram();\n    if (!program) throw webGLEntityCreationError(\"WebGLProgram\");\n    gl.attachShader(program, vertexShader);\n    gl.deleteShader(vertexShader);\n\n    gl.attachShader(program, fragmentShader);\n    gl.deleteShader(fragmentShader);\n\n    gl.linkProgram(program);\n\n    const success = gl.getProgramParameter(program, gl.LINK_STATUS);\n    if (!success) {\n        const message = gl.getProgramInfoLog(program);\n        gl.deleteProgram(program);\n        throw webGLError(`WebGLProgram linking failed with status: ${message}`);\n    }\n\n    return program;\n}\n\nexport function createShader(gl: WebGL2RenderingContext, source: string, type: number): WebGLShader {\n    const shader = gl.createShader(type);\n    if (!shader) throw webGLEntityCreationError(`WebGLShader (type ${type})`);\n    gl.shaderSource(shader, source);\n    gl.compileShader(shader);\n    const success = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n    if (!success) {\n        const message = gl.getShaderInfoLog(shader);\n        gl.deleteShader(shader);\n        throw webGLError(`WebGLShader (type ${type}) compilation failed with status: ${message}`);\n    }\n    return shader;\n}\n\nexport function createTexture(gl: WebGL2RenderingContext, width: number, height: number): WebGLTexture {\n    const texture = gl.createTexture();\n    if (!texture) throw webGLEntityCreationError(\"WebGLTexture\");\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);\n    return texture;\n}\n\nexport function createFramebuffer(gl: WebGL2RenderingContext, texture: WebGLTexture): WebGLFramebuffer {\n    const framebuffer = gl.createFramebuffer();\n    if (!framebuffer) throw webGLEntityCreationError(\"WebGLFramebuffer\");\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n    return framebuffer;\n}\n\nexport function setUniform1i(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, data: number): void {\n    gl.uniform1i(gl.getUniformLocation(program, name), data);\n}\n\nexport function setUniform4f(\n    gl: WebGL2RenderingContext,\n    program: WebGLProgram,\n    name: string,\n    data: [number, number, number, number]\n): void {\n    gl.uniform4f(gl.getUniformLocation(program, name), ...data);\n}\n\nexport function promiseSync(gl: WebGL2RenderingContext): Promise<void> {\n    const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);\n    if (!sync) throw webGLEntityCreationError(\"WebGLSync\");\n    gl.flush();\n    return new Promise((resolve, reject) => {\n        const waitForSync = (): void => {\n            const glEnum = gl.clientWaitSync(sync, 0, 0);\n            switch (glEnum) {\n                case gl.TIMEOUT_EXPIRED:\n                    setTimeout(waitForSync);\n                    return;\n                case gl.WAIT_FAILED:\n                    gl.deleteSync(sync);\n                    return reject();\n                case gl.ALREADY_SIGNALED:\n                case gl.CONDITION_SATISFIED:\n                    gl.deleteSync(sync);\n                    return resolve();\n            }\n        };\n        waitForSync();\n    });\n}\n"]}

package/lib/bootstrapCameraKit.d.ts

@@ -0,0 +1,96 @@
+import { Container } from "./dependency-injection/Container";
+import { CameraKit } from "./CameraKit";
+import { CameraKitBootstrapConfiguration } from "./configuration";
+import { PublicServices } from "./dependency-injection/RootServices";
+import { PartialContainer } from "./dependency-injection/PartialContainer";
+/**
+ * For more advanced use-cases, this DI Container holds services for which a custom implementation may be provided by
+ * the application.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare type PublicContainer = Container<PublicServices>;
+/**
+ * Bootstrap CameraKit. This will download the WebAssembly code which powers CameraKit's rendering engine, and return
+ * an instance of {@link CameraKit}.
+ *
+ * CameraKit must be provided with some configuration (the application's API token), and there are some additional
+ * configurations which are optional.
+ *
+ * Descriptions of the available configurations can be found in the documentation for
+ * {@link CameraKitBootstrapConfiguration}
+ *
+ * ---
+ *
+ * There is also a second, more advanced way to modify CameraKit to provide greater flexibility to support less common
+ * use cases.
+ *
+ * This requires some knowledge of CameraKit's dependency injection system, and allows applications to provide their
+ * own custom implementations of certain CameraKit components. This functionality will only be needed by applications
+ * with very specific, more advanced requirements.
+ *
+ * @example
+ * ```ts
+ * // The most common way to bootstrap:
+ * const cameraKit = await bootstrapCameraKit({ apiToken: myApiToken })
+ *
+ * // For special advanced use-cases, it is possible to provide custom implementations for certain CameraKit components.
+ * const cameraKit = await bootstrapCameraKit(config, (container) => {
+ *   return container.provides(myCustomRemoteMediaAssetLoaderFactory)
+ * })
+ * ```
+ *
+ * @param configuration Configure CameraKit with e.g. credentials, global resource endpoints, etc.
+ * @param provide Optional function that can make modifications to CameraKit's root DI container.
+ * @returns A {@link CameraKit} instance, which is the entry point to CameraKit's API.
+ *
+ * @throws
+ *  - {@link ConfigurationError} when provided configuration object is invalid
+ *  - {@link PlatformNotSupportedError} when current platform is not supported by CameraKit
+ *  - {@link BootstrapError} when a failure occurs while initializing CameraKit and downloading the render engine
+ * WebAssembly binary.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function bootstrapCameraKit(configuration: CameraKitBootstrapConfiguration, provide?: (c: PublicContainer) => PublicContainer): Promise<CameraKit>;
+/**
+ * Extensions offer a way to provide custom implementations of certain parts of the CameraKit SDK.
+ *
+ * This enables more advanced use-cases, in which the default behavior of the SDK is substantially altered. For example,
+ * replacing the default implementation that loads remote lens assets with a custom implementation that returns
+ * different assets based on some business logic within the application.
+ *
+ * An extension is implemented as a [PartialContainer] – a collection of factory functions, each with its own
+ * dependencies, which each provide some "Service." A Service can be of any type, and the CameraKit SDK defines its
+ * own Services, some of which can be overridden by providing a custom implementation of the type via an extension.
+ *
+ * Here's an example of how extensions might be used:
+ * ```ts
+ * import { bootstrapCameraKit, createExtension, remoteMediaAssetLoaderFactory } from '@snap/camera-kit'
+ *
+ * const myCustomRemoteAssetLoader = Injectable(
+ *   remoteMediaAssetLoaderFactory.token,
+ *   [remoteMediaAssetLoaderFactory.token] as const,
+ *   (defaultLoader: AssetLoader): AssetLoader => {
+ *     return async (asset, lens) => {
+ *       if (lens?.id === MY_SPECIAL_LENS) {
+ *         return (await fetch('my/asset.glb')).arrayBuffer()
+ *       }
+ *       return defaultLoader(asset, lens)
+ *     }
+ *   },
+ * )
+ *
+ * const myExtension = createExtension().provides(myCustomeRemoteAssetLoader)
+ * const cameraKit = bootstrapCameraKit(config, container => container.provides(myExtension))
+ * ```
+ *
+ * This also enables greater modularity – the person/team creating the extension can do so in their own package, which
+ * could be shared by many applications that all require the same functionality.
+ *
+ * @returns A {@link PartialContainer} which can be used to create a collection of Services, and can later be provided
+ * to CameraKit's DI container during {@link bootstrapCameraKit}.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function createExtension(): PartialContainer;

package/lib/bootstrapCameraKit.js

@@ -0,0 +1,204 @@
+import { __awaiter } from "tslib";
+import { lensRepositoryFactory } from "./lens/LensRepository";
+import { Container } from "./dependency-injection/Container";
+import { cameraKitFactory } from "./CameraKit";
+import { lensCoreFactory } from "./lens-core-module/loader/lensCoreFactory";
+import { Injectable } from "./dependency-injection/Injectable";
+import { remoteMediaAssetLoaderFactory } from "./lens/assets/remoteMediaAssetLoaderFactory";
+import { deviceDependentAssetLoaderFactory } from "./lens/assets/deviceDependentAssetLoader";
+import { staticAssetLoaderFactory } from "./lens/assets/staticAssetLoader";
+import { defaultFetchHandlerFactory } from "./handlers/defaultFetchHandler";
+import { cameraKitServiceFetchHandlerFactory } from "./handlers/cameraKitServiceFetchHandlerFactory";
+import { createCameraKitConfigurationFactory } from "./configuration";
+import { PartialContainer } from "./dependency-injection/PartialContainer";
+import { metricsHandlerFactory } from "./metrics/metricsHandler";
+import { operationalMetricReporterFactory } from "./metrics/operationalMetricsReporter";
+import { lensSourcesFactory } from "./extensions/LensSources";
+import { uriHandlersFactory } from "./extensions/UriHandlers";
+import { assert } from "./common/assertions";
+import { isSafeString } from "./common/typeguards";
+import { metricsEventTargetFactory } from "./metrics/metricsEventTarget";
+import { reportGloballyScopedMetrics } from "./metrics/reporters/reporters";
+import { getLogger } from "./logger/logger";
+import { logEntriesFactory } from "./logger/logEntries";
+import { assertPlatformSupported } from "./assertPlatformSupported";
+import { lensPersistenceStoreFactory } from "./lens/LensPersistenceStore";
+import { remoteConfigurationFactory } from "./remote-configuration/remoteConfiguration";
+import { lensAssetRepositoryFactory } from "./lens/assets/LensAssetRepository";
+import { legalStateFactory } from "./legal/legalState";
+import { legalPromptFactory } from "./legal/legalPrompt";
+import { bootstrapError, configurationError } from "./namedErrors";
+import { businessEventsReporterFactory } from "./metrics/businessEventsReporter";
+import { reportGlobalException } from "./metrics/reporters/reportGlobalException";
+import { registerLogEntriesSubscriber } from "./logger/registerLogEntriesSubscriber";
+const logger = getLogger("bootstrapCameraKit");
+// The following errors are not wrapped with BootstrapError and bubble up as is.
+const nonWrappableErrors = [
+    "ConfigurationError",
+    "PlatformNotSupportedError",
+];
+/**
+ * Returns true if given error has to be wrapped with BoostrapError.
+ */
+function shouldWrapError(error) {
+    if (error instanceof Error) {
+        return !nonWrappableErrors.some((name) => error.name === name);
+    }
+    return true;
+}
+/**
+ * Bootstrap CameraKit. This will download the WebAssembly code which powers CameraKit's rendering engine, and return
+ * an instance of {@link CameraKit}.
+ *
+ * CameraKit must be provided with some configuration (the application's API token), and there are some additional
+ * configurations which are optional.
+ *
+ * Descriptions of the available configurations can be found in the documentation for
+ * {@link CameraKitBootstrapConfiguration}
+ *
+ * ---
+ *
+ * There is also a second, more advanced way to modify CameraKit to provide greater flexibility to support less common
+ * use cases.
+ *
+ * This requires some knowledge of CameraKit's dependency injection system, and allows applications to provide their
+ * own custom implementations of certain CameraKit components. This functionality will only be needed by applications
+ * with very specific, more advanced requirements.
+ *
+ * @example
+ * ```ts
+ * // The most common way to bootstrap:
+ * const cameraKit = await bootstrapCameraKit({ apiToken: myApiToken })
+ *
+ * // For special advanced use-cases, it is possible to provide custom implementations for certain CameraKit components.
+ * const cameraKit = await bootstrapCameraKit(config, (container) => {
+ *   return container.provides(myCustomRemoteMediaAssetLoaderFactory)
+ * })
+ * ```
+ *
+ * @param configuration Configure CameraKit with e.g. credentials, global resource endpoints, etc.
+ * @param provide Optional function that can make modifications to CameraKit's root DI container.
+ * @returns A {@link CameraKit} instance, which is the entry point to CameraKit's API.
+ *
+ * @throws
+ *  - {@link ConfigurationError} when provided configuration object is invalid
+ *  - {@link PlatformNotSupportedError} when current platform is not supported by CameraKit
+ *  - {@link BootstrapError} when a failure occurs while initializing CameraKit and downloading the render engine
+ * WebAssembly binary.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export function bootstrapCameraKit(configuration, provide) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const startTimeMs = performance.now();
+            assert(isSafeString(configuration.apiToken), configurationError("Unsafe apiToken"));
+            const configurationFactory = createCameraKitConfigurationFactory(configuration);
+            // Public container holds services which applications can overwrite with their own implementations.
+            const defaultPublicContainer = Container.provides(configurationFactory)
+                .provides(defaultFetchHandlerFactory)
+                .provides(remoteMediaAssetLoaderFactory)
+                .provides(lensSourcesFactory)
+                .provides(uriHandlersFactory);
+            const publicContainer = provide ? provide(defaultPublicContainer) : defaultPublicContainer;
+            // Now that the client's provide() function has completed and the configuration override is ready,
+            // we create another container to initialize the logger. This ensures that logging is available
+            // as we continue bootstrapping. We don't initialize the logger as part of the defaultPublicContainer
+            // because we don't want applications to provide their own logger implementations,
+            // and we're not interested in errors thrown by their provide() function.
+            // Below is the minimum required container to report errors to Blizzard.
+            const telemetryContainer = Container.provides(publicContainer)
+                .provides(logEntriesFactory)
+                .provides(cameraKitServiceFetchHandlerFactory)
+                .provides(metricsEventTargetFactory)
+                .provides(metricsHandlerFactory)
+                .provides(operationalMetricReporterFactory)
+                .provides(reportGlobalException)
+                .run(businessEventsReporterFactory)
+                .run(registerLogEntriesSubscriber);
+            // Run the exception logger so that it can subscribe to log events -- we can't use `Container.run()` because
+            // reportGlobalException is also used as a dependency by other Services (and run does not provide Services,
+            // it just runs them once).
+            telemetryContainer.get(reportGlobalException.token);
+            // At this point, logger is configured to report to console and Blizzard.
+            assertPlatformSupported();
+            // LensCore is a foundational component which must be created asynchronously.
+            // But it's annoying for every consumer of LensCore to have to wait on Promise<LensCore>
+            // (which means they become async themselves). So we'll create a DI container which provides Promise<LensCore>,
+            // wait for that promise once here, then create a new DI container that just contains LensCore.
+            const lensCore = yield telemetryContainer.provides(lensCoreFactory).get(lensCoreFactory.token);
+            const container = telemetryContainer
+                .provides(Injectable(lensCoreFactory.token, () => lensCore))
+                .provides(remoteConfigurationFactory)
+                .provides(lensPersistenceStoreFactory)
+                .provides(deviceDependentAssetLoaderFactory)
+                .provides(staticAssetLoaderFactory)
+                .provides(lensAssetRepositoryFactory)
+                .provides(lensRepositoryFactory)
+                .provides(legalPromptFactory)
+                .provides(legalStateFactory)
+                .provides(cameraKitFactory)
+                // We'll run a PartialContainer containing reporters for globally-scoped metrics. Running this container
+                // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain
+                // actions occur). This PartialContainer also includes the service which listens to locally-reported metrics
+                // and sends them to our backend.
+                .run(reportGloballyScopedMetrics);
+            const cameraKit = container.get(cameraKitFactory.token);
+            const bootstrapTimeMs = performance.now() - startTimeMs;
+            const reporter = container.get(operationalMetricReporterFactory.token);
+            reporter.timer("bootstrap_time", bootstrapTimeMs);
+            return cameraKit;
+        }
+        catch (error) {
+            if (shouldWrapError(error)) {
+                error = bootstrapError("Failed to bootstrap Camera Kit.", error);
+            }
+            logger.error(error);
+            throw error;
+        }
+    });
+}
+/**
+ * Extensions offer a way to provide custom implementations of certain parts of the CameraKit SDK.
+ *
+ * This enables more advanced use-cases, in which the default behavior of the SDK is substantially altered. For example,
+ * replacing the default implementation that loads remote lens assets with a custom implementation that returns
+ * different assets based on some business logic within the application.
+ *
+ * An extension is implemented as a [PartialContainer] – a collection of factory functions, each with its own
+ * dependencies, which each provide some "Service." A Service can be of any type, and the CameraKit SDK defines its
+ * own Services, some of which can be overridden by providing a custom implementation of the type via an extension.
+ *
+ * Here's an example of how extensions might be used:
+ * ```ts
+ * import { bootstrapCameraKit, createExtension, remoteMediaAssetLoaderFactory } from '@snap/camera-kit'
+ *
+ * const myCustomRemoteAssetLoader = Injectable(
+ *   remoteMediaAssetLoaderFactory.token,
+ *   [remoteMediaAssetLoaderFactory.token] as const,
+ *   (defaultLoader: AssetLoader): AssetLoader => {
+ *     return async (asset, lens) => {
+ *       if (lens?.id === MY_SPECIAL_LENS) {
+ *         return (await fetch('my/asset.glb')).arrayBuffer()
+ *       }
+ *       return defaultLoader(asset, lens)
+ *     }
+ *   },
+ * )
+ *
+ * const myExtension = createExtension().provides(myCustomeRemoteAssetLoader)
+ * const cameraKit = bootstrapCameraKit(config, container => container.provides(myExtension))
+ * ```
+ *
+ * This also enables greater modularity – the person/team creating the extension can do so in their own package, which
+ * could be shared by many applications that all require the same functionality.
+ *
+ * @returns A {@link PartialContainer} which can be used to create a collection of Services, and can later be provided
+ * to CameraKit's DI container during {@link bootstrapCameraKit}.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export function createExtension() {
+    return new PartialContainer({});
+}
+//# sourceMappingURL=bootstrapCameraKit.js.map