@babylonjs-toolkit/next 9.30.0 → 9.34.0

package/lib/contentinstaller.js

@@ -0,0 +1,1929 @@
+import { Observable } from '@babylonjs/core/Misc/observable';
+export class ContentInstaller {
+    static Initialize(options) {
+        if (ContentInstaller.initializePromise != null)
+            return ContentInstaller.initializePromise;
+        ContentInstaller.initializePromise = ContentInstaller.runInitialize(options);
+        return ContentInstaller.initializePromise;
+    }
+    static GetState() {
+        return { ...ContentInstaller.state };
+    }
+    static GetGroupStatus(groupIds) {
+        return ContentInstaller.resolveGroups(groupIds, true).map((groupRef) => ContentInstaller.groupStatus(groupRef));
+    }
+    static GetGroupIds() {
+        const groupIds = [];
+        ContentInstaller.roots.forEach((root) => {
+            if (root.state.isAppShell || root.activeManifest == null)
+                return;
+            for (const groupId of Object.keys(root.activeManifest.groups)) {
+                if (groupIds.indexOf(groupId) < 0)
+                    groupIds.push(groupId);
+            }
+        });
+        return groupIds;
+    }
+    static async EstimateInstall(groupIds) {
+        const missingFiles = ContentInstaller.missingFiles(ContentInstaller.groupFiles(ContentInstaller.resolveGroups(groupIds, true)));
+        return ContentInstaller.estimateFor(missingFiles);
+    }
+    static Install(groupIds, options) {
+        if (ContentInstaller.state.availability !== "available")
+            return Promise.resolve(false);
+        const background = (options != null && options.background === true);
+        const prepareGraphics = (options != null && options.prepareGraphics === true);
+        const requestedIds = ContentInstaller.normalizeGroupIds(groupIds);
+        if (!ContentInstaller.state.isLeader)
+            return ContentInstaller.forwardToLeader("install-request", requestedIds, background, prepareGraphics, false);
+        return ContentInstaller.installThenPrepareAsLeader(requestedIds, background, prepareGraphics, null);
+    }
+    static PrepareGraphicsAsync(groupIds, options) {
+        if (ContentInstaller.state.availability !== "available")
+            return Promise.resolve(false);
+        const background = (options != null && options.background === true);
+        const force = (options != null && options.force === true);
+        const requestedIds = ContentInstaller.normalizeGroupIds(groupIds);
+        if (!ContentInstaller.state.isLeader)
+            return ContentInstaller.forwardToLeader("prepare-graphics-request", requestedIds, background, false, force);
+        return ContentInstaller.prepareGraphicsAsLeader(requestedIds, background, force, null);
+    }
+    static async MarkGraphicsStale() {
+        if (!ContentInstaller.state.isLeader)
+            return;
+        for (const root of Array.from(ContentInstaller.roots.values())) {
+            const preparedIds = Object.keys(root.state.graphics).filter((groupId) => root.state.graphics[groupId].outcome === "prepared");
+            if (preparedIds.length === 0)
+                continue;
+            for (const groupId of preparedIds) {
+                const record = { ...root.state.graphics[groupId], gpuCacheLost: true };
+                root.state.graphics[groupId] = record;
+                ContentInstaller.postToChannel({ type: "graphics-recorded", rootKey: root.state.rootKey, groupId: groupId, graphicsRecord: record });
+            }
+            await ContentInstaller.writeRootState(root);
+        }
+        ContentInstaller.updateTotalsState();
+    }
+    static applyGpuCacheReport() {
+        if (!ContentInstaller.state.isLeader)
+            return;
+        try {
+            if (localStorage.getItem(ContentInstaller.GPU_CACHE_LOST_STORAGE_KEY) == null)
+                return;
+            localStorage.removeItem(ContentInstaller.GPU_CACHE_LOST_STORAGE_KEY);
+        }
+        catch {
+            return;
+        }
+        void ContentInstaller.MarkGraphicsStale();
+    }
+    static listenForGpuCacheReports() {
+        if (ContentInstaller.listensForGpuCacheReports || typeof window === "undefined")
+            return;
+        ContentInstaller.listensForGpuCacheReports = true;
+        window.addEventListener(ContentInstaller.GPU_CACHE_LOST_EVENT, ContentInstaller.applyGpuCacheReport);
+    }
+    static SetGraphicsPreparer(preparer) {
+        ContentInstaller.graphicsPreparer = (preparer != null) ? preparer : null;
+        ContentInstaller.graphicsUnavailable = false;
+        ContentInstaller.updateTotalsState();
+    }
+    static Pause() {
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        if (!ContentInstaller.state.isLeader) {
+            ContentInstaller.postToChannel({ type: "pause" });
+            return;
+        }
+        if (ContentInstaller.state.paused)
+            return;
+        ContentInstaller.setState({ paused: true });
+        ContentInstaller.abortInFlight("pause");
+    }
+    static Resume() {
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        if (!ContentInstaller.state.isLeader) {
+            ContentInstaller.postToChannel({ type: "resume" });
+            return;
+        }
+        ContentInstaller.setState({ paused: false });
+        ContentInstaller.pumpQueue();
+    }
+    static Cancel() {
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        if (!ContentInstaller.state.isLeader) {
+            ContentInstaller.postToChannel({ type: "cancel" });
+            return;
+        }
+        ContentInstaller.queue = [];
+        ContentInstaller.clearRetryWaits();
+        ContentInstaller.abortInFlight("cancel");
+        ContentInstaller.cancelCount += 1;
+        if (ContentInstaller.graphicsRun != null)
+            ContentInstaller.graphicsCancelled = true;
+        ContentInstaller.wakeGraphicsWaiters();
+        const cancelledCalls = ContentInstaller.installCalls;
+        ContentInstaller.installCalls = [];
+        ContentInstaller.failedHashes.clear();
+        ContentInstaller.endSession();
+        ContentInstaller.setState({ paused: false });
+        void ContentInstaller.completeCalls(cancelledCalls, true);
+    }
+    static async Remove(groupIds) {
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        const requestedIds = ContentInstaller.normalizeGroupIds(groupIds);
+        if (!ContentInstaller.state.isLeader) {
+            await ContentInstaller.forwardToLeader("remove-request", requestedIds, false, false, false);
+            return;
+        }
+        await ContentInstaller.removeAsLeader(requestedIds);
+    }
+    static async CheckForUpdates() {
+        if (ContentInstaller.state.availability !== "available")
+            return [];
+        for (const root of Array.from(ContentInstaller.roots.values())) {
+            const manifest = await ContentInstaller.fetchManifest(root.state.rootKey);
+            if (manifest == null)
+                continue;
+            await ContentInstaller.takeServerManifest(root, manifest);
+        }
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.persistRoots(false);
+        ContentInstaller.updateTotalsState();
+        ContentInstaller.runUpdatePolicies();
+        return ContentInstaller.rootsWithPending().map((root) => ContentInstaller.updateInfo(root));
+    }
+    static DownloadUpdate() {
+        if (ContentInstaller.state.availability !== "available")
+            return Promise.resolve(false);
+        if (!ContentInstaller.state.isLeader)
+            return Promise.resolve(ContentInstaller.state.updateReady);
+        const contentRoots = ContentInstaller.rootsWithPending().filter((root) => !root.state.isAppShell);
+        return ContentInstaller.downloadUpdateFor(contentRoots);
+    }
+    static AcceptUpdate() {
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        for (const root of ContentInstaller.rootsWithPending()) {
+            if (root.state.isAppShell || !ContentInstaller.isPendingReady(root))
+                continue;
+            root.state.applyOnNextLoad = true;
+        }
+        if (ContentInstaller.state.isLeader)
+            void ContentInstaller.persistRoots(false);
+        ContentInstaller.updateTotalsState();
+    }
+    static ApplyShellUpdate() {
+        ContentInstaller.roots.forEach((root) => {
+            if (root.state.isAppShell && root.pendingManifest != null)
+                root.state.applyOnNextLoad = true;
+        });
+        const reload = () => { location.reload(); };
+        const writes = ContentInstaller.state.isLeader ? ContentInstaller.persistRoots(false) : Promise.resolve();
+        void writes.then(() => {
+            const waitingWorker = (ContentInstaller.registration != null) ? ContentInstaller.registration.waiting : null;
+            if (waitingWorker == null) {
+                reload();
+                return;
+            }
+            navigator.serviceWorker.addEventListener("controllerchange", reload, { once: true });
+            waitingWorker.postMessage({ type: "skip-waiting" });
+        });
+    }
+    static async PrepareSceneLoad(sceneUrl) {
+        if (ContentInstaller.state.availability !== "available")
+            return false;
+        await ContentInstaller.refreshStoredHashes();
+        ContentInstaller.roots.forEach((root) => { ContentInstaller.recomputeInstalledGroups(root, false); });
+        let activated = false;
+        ContentInstaller.roots.forEach((root) => {
+            if (root.pendingManifest == null || !ContentInstaller.isPendingReady(root))
+                return;
+            const accepted = root.state.applyOnNextLoad || ContentInstaller.effectiveUpdatePolicy(root) === "automatic";
+            if (!accepted)
+                return;
+            ContentInstaller.activatePending(root);
+            activated = true;
+        });
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.persistRoots(activated);
+        ContentInstaller.pinRoots();
+        const sceneGroup = ContentInstaller.findSceneGroup(sceneUrl);
+        if (sceneGroup != null)
+            ContentInstaller.prioritiseGroup(sceneGroup);
+        ContentInstaller.SetBusy(true);
+        ContentInstaller.updateTotalsState();
+        return ContentInstaller.IsSceneInstalled(sceneUrl);
+    }
+    static SetBusy(busy) {
+        ContentInstaller.busy = busy;
+        ContentInstaller.pumpQueue();
+        ContentInstaller.wakeGraphicsWaiters();
+    }
+    static IsSceneInstalled(sceneUrl) {
+        const sceneGroup = ContentInstaller.findSceneGroup(sceneUrl);
+        if (sceneGroup == null)
+            return false;
+        return sceneGroup.root.state.installedGroups.indexOf(sceneGroup.groupId) >= 0;
+    }
+    static async RequestPersistentStorage() {
+        let persisted = false;
+        try {
+            if (typeof navigator !== "undefined" && navigator.storage != null && typeof navigator.storage.persist === "function") {
+                persisted = await navigator.storage.persist();
+            }
+        }
+        catch {
+            persisted = false;
+        }
+        ContentInstaller.setState({ persisted: persisted });
+        return persisted;
+    }
+    static GroupIdFromSceneFile(fileName) {
+        const withoutQuery = ContentInstaller.stripQueryAndHash(fileName);
+        const lastSegment = withoutQuery.substring(withoutQuery.lastIndexOf("/") + 1).toLowerCase();
+        for (const suffix of ContentInstaller.SCENE_FILE_SUFFIXES) {
+            if (lastSegment.endsWith(suffix))
+                return lastSegment.substring(0, lastSegment.length - suffix.length);
+        }
+        return lastSegment;
+    }
+    static async runInitialize(options) {
+        const settings = ContentInstaller.normalizeOptions(options);
+        ContentInstaller.options = settings;
+        if (settings.graphicsPreparer != null)
+            ContentInstaller.graphicsPreparer = settings.graphicsPreparer;
+        ContentInstaller.tabStartTime = Date.now();
+        ContentInstaller.setState({ installPolicy: settings.installPolicy, updatePolicy: settings.updatePolicy });
+        const blocked = ContentInstaller.checkAvailability(settings);
+        if (blocked != null)
+            return ContentInstaller.stopWith(blocked.availability, blocked.reason);
+        const registered = await ContentInstaller.registerWorker(settings);
+        if (!registered)
+            return ContentInstaller.stopWith("unavailable", "the content worker could not be registered");
+        const controlled = await ContentInstaller.waitForController();
+        if (!controlled)
+            return ContentInstaller.stopWith("unavailable", "page not controlled (hard reload)");
+        ContentInstaller.openChannel();
+        await ContentInstaller.electLeader();
+        await ContentInstaller.loadRoots(settings.roots);
+        ContentInstaller.setState({ availability: "available", reason: null });
+        ContentInstaller.watchConnectivity();
+        if (ContentInstaller.state.isLeader)
+            ContentInstaller.startLeaderWork();
+        return ContentInstaller.GetState();
+    }
+    static normalizeOptions(options) {
+        return {
+            roots: (options.roots != null) ? options.roots : [],
+            workerUrl: options.workerUrl,
+            workerScope: options.workerScope,
+            installPolicy: (options.installPolicy != null) ? options.installPolicy : "as-you-play",
+            updatePolicy: (options.updatePolicy != null) ? options.updatePolicy : "prompt",
+            enableOnLocalHost: options.enableOnLocalHost === true,
+            graphicsPreparer: (options.graphicsPreparer != null) ? options.graphicsPreparer : null,
+        };
+    }
+    static checkAvailability(options) {
+        if (typeof navigator === "undefined" || !("serviceWorker" in navigator))
+            return { availability: "unavailable", reason: "this browser has no service workers" };
+        if (typeof caches === "undefined")
+            return { availability: "unavailable", reason: "this browser has no Cache Storage" };
+        if (typeof isSecureContext !== "undefined" && isSecureContext === false)
+            return { availability: "unavailable", reason: "the page is not a secure context" };
+        if (!options.enableOnLocalHost && ContentInstaller.isLocalHost(location.hostname))
+            return { availability: "disabled", reason: "local host (enableOnLocalHost is off)" };
+        if (options.installPolicy === "off")
+            return { availability: "disabled", reason: "the install policy is off" };
+        return null;
+    }
+    static async stopWith(availability, reason) {
+        if (availability === "disabled")
+            await ContentInstaller.unregisterWorkers();
+        ContentInstaller.setState({ availability: availability, reason: reason });
+        return ContentInstaller.GetState();
+    }
+    static async unregisterWorkers() {
+        if (typeof navigator === "undefined" || navigator.serviceWorker == null)
+            return;
+        try {
+            const registrations = await navigator.serviceWorker.getRegistrations();
+            for (const registration of registrations) {
+                const worker = registration.active || registration.waiting || registration.installing;
+                if (worker == null || !ContentInstaller.stripQueryAndHash(worker.scriptURL).endsWith(ContentInstaller.WORKER_SCRIPT_NAME))
+                    continue;
+                await registration.unregister();
+            }
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not unregister the content worker: " + String(error));
+        }
+    }
+    static async registerWorker(options) {
+        const workerUrl = ContentInstaller.absoluteUrl(options.workerUrl);
+        const scope = (options.workerScope != null) ? options.workerScope : ContentInstaller.folderOf(workerUrl);
+        try {
+            const registration = await navigator.serviceWorker.register(workerUrl, { scope: scope });
+            ContentInstaller.registration = registration;
+            ContentInstaller.watchWorkerUpdates(registration);
+            return true;
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] The content worker could not be registered: " + String(error));
+            return false;
+        }
+    }
+    static watchWorkerUpdates(registration) {
+        if (registration.waiting != null && navigator.serviceWorker.controller != null)
+            ContentInstaller.markWorkerUpdateWaiting();
+        if (typeof registration.addEventListener !== "function")
+            return;
+        registration.addEventListener("updatefound", () => {
+            const installing = registration.installing;
+            if (installing == null)
+                return;
+            installing.addEventListener("statechange", () => {
+                if (installing.state === "installed" && navigator.serviceWorker.controller != null)
+                    ContentInstaller.markWorkerUpdateWaiting();
+            });
+        });
+    }
+    static markWorkerUpdateWaiting() {
+        ContentInstaller.workerUpdateWaiting = true;
+        ContentInstaller.setState({ shellUpdateReady: true });
+    }
+    static waitForController() {
+        const container = navigator.serviceWorker;
+        if (container.controller != null)
+            return Promise.resolve(true);
+        return new Promise((resolve) => {
+            let finished = false;
+            const finish = () => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                container.removeEventListener("controllerchange", finish);
+                resolve(container.controller != null);
+            };
+            const timer = setTimeout(finish, ContentInstaller.CONTROLLER_WAIT_MS);
+            container.addEventListener("controllerchange", finish);
+        });
+    }
+    static openChannel() {
+        if (typeof BroadcastChannel === "undefined")
+            return;
+        ContentInstaller.channel = new BroadcastChannel(ContentInstaller.BROADCAST_CHANNEL_NAME);
+        ContentInstaller.channel.onmessage = (event) => { ContentInstaller.handleChannelMessage(event.data); };
+    }
+    static async electLeader() {
+        const locks = (typeof navigator !== "undefined") ? navigator.locks : undefined;
+        if (locks == null || typeof locks.request !== "function") {
+            ContentInstaller.setState({ isLeader: true });
+            return;
+        }
+        const won = await new Promise((resolve) => {
+            locks.request(ContentInstaller.LOCK_NAME, { ifAvailable: true }, (lock) => {
+                resolve(lock != null);
+                return (lock != null) ? ContentInstaller.holdLeadership() : undefined;
+            }).catch(() => { resolve(true); });
+        });
+        if (won) {
+            ContentInstaller.setState({ isLeader: true });
+            return;
+        }
+        void locks.request(ContentInstaller.LOCK_NAME, () => {
+            void ContentInstaller.onLeadershipGranted();
+            return ContentInstaller.holdLeadership();
+        });
+    }
+    static holdLeadership() {
+        return new Promise(() => undefined);
+    }
+    static async onLeadershipGranted() {
+        ContentInstaller.setState({ isLeader: true });
+        if (ContentInstaller.state.availability !== "available")
+            return;
+        for (const root of Array.from(ContentInstaller.roots.values())) {
+            const persisted = await ContentInstaller.readRootState(root.state.rootKey);
+            if (persisted == null)
+                continue;
+            root.state.requestedGroups = ContentInstaller.union(root.state.requestedGroups, persisted.requestedGroups);
+            root.state.graphics = Object.assign({}, root.state.graphics, persisted.graphics || {});
+        }
+        await ContentInstaller.refreshStoredHashes();
+        ContentInstaller.roots.forEach((root) => { ContentInstaller.recomputeInstalledGroups(root, false); });
+        await ContentInstaller.persistRoots(false);
+        ContentInstaller.updateTotalsState();
+        ContentInstaller.replayForwardedRequests();
+        ContentInstaller.startLeaderWork();
+    }
+    static replayForwardedRequests() {
+        const forwarded = Array.from(ContentInstaller.forwardedRequests.values());
+        ContentInstaller.forwardedRequests.clear();
+        for (const request of forwarded) {
+            if (request.kind === "remove-request") {
+                void ContentInstaller.removeAsLeader(request.groupIds).then(() => { request.resolve(true); });
+                continue;
+            }
+            if (request.kind === "prepare-graphics-request") {
+                void ContentInstaller.prepareGraphicsAsLeader(request.groupIds, request.background, request.force, null).then(request.resolve);
+                continue;
+            }
+            void ContentInstaller.installThenPrepareAsLeader(request.groupIds, request.background, request.prepareGraphics, null).then(request.resolve);
+        }
+    }
+    static startLeaderWork() {
+        ContentInstaller.listenForGpuCacheReports();
+        ContentInstaller.applyGpuCacheReport();
+        ContentInstaller.resumeRequestedGroups();
+        if (ContentInstaller.state.installPolicy === "everything")
+            void ContentInstaller.installAsLeader(null, false, null, true);
+        ContentInstaller.runUpdatePolicies();
+    }
+    static resumeRequestedGroups() {
+        const groupIds = [];
+        ContentInstaller.roots.forEach((root) => {
+            for (const groupId of root.state.requestedGroups) {
+                if (root.state.installedGroups.indexOf(groupId) < 0 && groupIds.indexOf(groupId) < 0)
+                    groupIds.push(groupId);
+            }
+        });
+        if (groupIds.length > 0)
+            void ContentInstaller.installAsLeader(groupIds, false, null, true);
+    }
+    static watchConnectivity() {
+        if (typeof window === "undefined" || typeof window.addEventListener !== "function")
+            return;
+        window.addEventListener("online", () => { void ContentInstaller.CheckForUpdates(); });
+    }
+    static async loadRoots(rootOptions) {
+        for (const options of rootOptions) {
+            const root = await ContentInstaller.loadRoot(options);
+            if (root != null)
+                ContentInstaller.roots.set(root.state.rootKey, root);
+        }
+        await ContentInstaller.refreshStoredHashes();
+        let activated = false;
+        ContentInstaller.roots.forEach((root) => {
+            ContentInstaller.recomputeInstalledGroups(root, true);
+            if (ContentInstaller.applyStartupUpdate(root))
+                activated = true;
+        });
+        ContentInstaller.rebuildGroupIndex();
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.persistRoots(activated);
+        ContentInstaller.pinRoots();
+        ContentInstaller.updateTotalsState();
+    }
+    static async loadRoot(options) {
+        const rootKey = ContentInstaller.absoluteUrl(options.manifestUrl);
+        const manifest = await ContentInstaller.fetchManifest(rootKey);
+        if (manifest == null) {
+            ContentInstaller.reportError("manifest", "[ContentInstaller] No content manifest at " + rootKey + ": content loads from the network.", []);
+            return null;
+        }
+        const baseUrl = ContentInstaller.ensureTrailingSlash((options.baseUrl != null) ? ContentInstaller.absoluteUrl(options.baseUrl) : ContentInstaller.folderOf(rootKey));
+        const persisted = await ContentInstaller.readRootState(rootKey);
+        const root = { state: (persisted != null) ? persisted : ContentInstaller.createRootState(rootKey), activeManifest: null, pendingManifest: null };
+        root.state.baseUrl = baseUrl;
+        root.state.isAppShell = options.isAppShell === true;
+        root.state.installPolicy = ContentInstaller.state.installPolicy;
+        root.state.networkOnly = (root.state.networkOnly != null) ? root.state.networkOnly : null;
+        root.state.graphics = (root.state.graphics != null) ? root.state.graphics : {};
+        await ContentInstaller.restoreManifests(root, manifest);
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.storeManifest(rootKey, manifest);
+        return root;
+    }
+    static async restoreManifests(root, serverManifest) {
+        const activeManifest = await ContentInstaller.findActiveManifest(root, serverManifest);
+        if (activeManifest == null) {
+            ContentInstaller.makeActive(root, serverManifest);
+            return;
+        }
+        root.activeManifest = activeManifest;
+        await ContentInstaller.takeServerManifest(root, serverManifest);
+    }
+    static async findActiveManifest(root, serverManifest) {
+        const activeVersion = root.state.activeVersion;
+        if (activeVersion == null)
+            return null;
+        if (activeVersion === serverManifest.version)
+            return serverManifest;
+        return ContentInstaller.readStoredManifest(root.state.rootKey, activeVersion);
+    }
+    static async takeServerManifest(root, serverManifest) {
+        const networkOnly = root.state.networkOnly;
+        if (networkOnly != null && networkOnly.serverVersion !== serverManifest.version)
+            root.state.networkOnly = null;
+        if (serverManifest.version === root.state.activeVersion) {
+            root.pendingManifest = null;
+            root.state.pendingVersion = null;
+            root.state.applyOnNextLoad = false;
+            return;
+        }
+        if (serverManifest.version !== root.state.pendingVersion) {
+            root.state.pendingVersion = serverManifest.version;
+            root.state.applyOnNextLoad = false;
+        }
+        root.pendingManifest = serverManifest;
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.storeManifest(root.state.rootKey, serverManifest);
+        const nothingInstalled = root.state.installedGroups.length === 0;
+        if (nothingInstalled && ContentInstaller.progress == null)
+            ContentInstaller.activatePending(root);
+    }
+    static applyStartupUpdate(root) {
+        if (root.pendingManifest == null)
+            return false;
+        const nothingInstalled = root.state.installedGroups.length === 0;
+        const accepted = root.state.applyOnNextLoad || ContentInstaller.effectiveUpdatePolicy(root) === "automatic";
+        if (!nothingInstalled && !(accepted && ContentInstaller.isPendingReady(root)))
+            return false;
+        ContentInstaller.activatePending(root);
+        return true;
+    }
+    static makeActive(root, manifest) {
+        root.activeManifest = manifest;
+        root.state.activeVersion = manifest.version;
+        root.pendingManifest = null;
+        root.state.pendingVersion = null;
+        root.state.applyOnNextLoad = false;
+        const networkOnly = root.state.networkOnly;
+        if (networkOnly != null && networkOnly.reason === "update-pending" && networkOnly.serverVersion === manifest.version)
+            root.state.networkOnly = null;
+    }
+    static activatePending(root) {
+        const previousVersion = root.state.activeVersion;
+        ContentInstaller.makeActive(root, root.pendingManifest);
+        ContentInstaller.retargetQueuedJobs(root, previousVersion);
+        ContentInstaller.rebuildGroupIndex();
+        ContentInstaller.recomputeInstalledGroups(root, false);
+    }
+    static retargetQueuedJobs(root, previousVersion) {
+        const manifest = root.activeManifest;
+        const kept = [];
+        for (const job of ContentInstaller.queue) {
+            if (job.rootKey !== root.state.rootKey || job.version !== previousVersion) {
+                kept.push(job);
+                continue;
+            }
+            const entry = manifest.files[job.path];
+            if (entry != null && entry.hash === job.hash) {
+                job.version = manifest.version;
+                kept.push(job);
+                continue;
+            }
+            ContentInstaller.failedHashes.add(job.hash);
+        }
+        ContentInstaller.queue = kept;
+        ContentInstaller.settleFinishedCalls();
+    }
+    static async fetchManifest(url) {
+        try {
+            const response = await fetch(url, { cache: "no-store" });
+            if (!response.ok)
+                return null;
+            const manifest = await response.json();
+            return ContentInstaller.isValidManifest(manifest) ? manifest : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static isValidManifest(manifest) {
+        if (manifest == null || typeof manifest !== "object")
+            return false;
+        if (manifest.format !== ContentInstaller.SUPPORTED_MANIFEST_FORMAT || typeof manifest.version !== "string")
+            return false;
+        return manifest.files != null && typeof manifest.files === "object" && manifest.groups != null && typeof manifest.groups === "object";
+    }
+    static effectiveUpdatePolicy(root) {
+        return root.state.isAppShell ? "automatic" : ContentInstaller.state.updatePolicy;
+    }
+    static storeKey(path) {
+        return new URL(ContentInstaller.STORE_KEY_PREFIX + path, location.origin).href;
+    }
+    static fileKey(hash) {
+        return ContentInstaller.storeKey("files/" + hash);
+    }
+    static rootStateKey(rootKey) {
+        return ContentInstaller.storeKey("roots/" + encodeURIComponent(rootKey));
+    }
+    static manifestKey(rootKey, version) {
+        return ContentInstaller.storeKey("manifests/" + encodeURIComponent(rootKey) + "/" + version);
+    }
+    static async readStateJson(key) {
+        try {
+            const cache = await caches.open(ContentInstaller.CONTENT_STATE_CACHE);
+            const response = await cache.match(key);
+            return (response != null) ? await response.json() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async writeStateJson(key, value) {
+        try {
+            const cache = await caches.open(ContentInstaller.CONTENT_STATE_CACHE);
+            await cache.put(key, new Response(JSON.stringify(value), { headers: { "Content-Type": "application/json" } }));
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not write installer state: " + String(error));
+        }
+    }
+    static readRootState(rootKey) {
+        return ContentInstaller.readStateJson(ContentInstaller.rootStateKey(rootKey));
+    }
+    static writeRootState(root) {
+        root.state.updatedAt = ContentInstaller.Clock();
+        return ContentInstaller.writeStateJson(ContentInstaller.rootStateKey(root.state.rootKey), root.state);
+    }
+    static async readStoredManifest(rootKey, version) {
+        const manifest = await ContentInstaller.readStateJson(ContentInstaller.manifestKey(rootKey, version));
+        return ContentInstaller.isValidManifest(manifest) ? manifest : null;
+    }
+    static storeManifest(rootKey, manifest) {
+        return ContentInstaller.writeStateJson(ContentInstaller.manifestKey(rootKey, manifest.version), manifest);
+    }
+    static async persistRoots(collectGarbage) {
+        for (const root of Array.from(ContentInstaller.roots.values()))
+            await ContentInstaller.writeRootState(root);
+        const indexKey = ContentInstaller.storeKey("roots-index");
+        const existing = await ContentInstaller.readStateJson(indexKey);
+        await ContentInstaller.writeStateJson(indexKey, ContentInstaller.union(Array.isArray(existing) ? existing : [], Array.from(ContentInstaller.roots.keys())));
+        ContentInstaller.postToWorker({ type: "roots-changed" });
+        if (collectGarbage)
+            ContentInstaller.postToWorker({ type: "collect-garbage" });
+    }
+    static async refreshStoredHashes() {
+        try {
+            const cache = await caches.open(ContentInstaller.CONTENT_FILES_CACHE);
+            const requests = await cache.keys();
+            const prefix = ContentInstaller.fileKey("");
+            const hashes = new Set();
+            for (const request of requests) {
+                if (request.url.startsWith(prefix))
+                    hashes.add(request.url.substring(prefix.length));
+            }
+            ContentInstaller.storedHashes = hashes;
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not read the content store: " + String(error));
+        }
+    }
+    static async isHashStored(hash) {
+        try {
+            const cache = await caches.open(ContentInstaller.CONTENT_FILES_CACHE);
+            return (await cache.match(ContentInstaller.fileKey(hash))) != null;
+        }
+        catch {
+            return false;
+        }
+    }
+    static rebuildGroupIndex() {
+        const index = new Map();
+        ContentInstaller.roots.forEach((root) => {
+            if (root.activeManifest == null)
+                return;
+            for (const [groupId, group] of Object.entries(root.activeManifest.groups)) {
+                for (const path of group.files) {
+                    const entry = root.activeManifest.files[path];
+                    if (entry == null)
+                        continue;
+                    const groupRefs = index.get(entry.hash) || [];
+                    groupRefs.push({ root: root, groupId: groupId });
+                    index.set(entry.hash, groupRefs);
+                }
+            }
+        });
+        ContentInstaller.groupsByHash = index;
+    }
+    static isGroupStored(manifest, groupId) {
+        const group = manifest.groups[groupId];
+        if (group == null)
+            return false;
+        return group.files.every((path) => {
+            const entry = manifest.files[path];
+            return entry == null || ContentInstaller.storedHashes.has(entry.hash);
+        });
+    }
+    static recomputeInstalledGroups(root, reportEviction) {
+        const manifest = root.activeManifest;
+        if (manifest == null)
+            return;
+        const previous = root.state.installedGroups || [];
+        const installed = Object.keys(manifest.groups).filter((groupId) => ContentInstaller.isGroupStored(manifest, groupId));
+        root.state.installedGroups = installed;
+        if (!reportEviction)
+            return;
+        const evicted = previous.filter((groupId) => manifest.groups[groupId] != null && installed.indexOf(groupId) < 0);
+        if (evicted.length === 0)
+            return;
+        root.state.requestedGroups = (root.state.requestedGroups || []).filter((groupId) => evicted.indexOf(groupId) < 0);
+        const missingPaths = ContentInstaller.missingFiles(ContentInstaller.groupFiles(evicted.map((groupId) => ({ root: root, groupId: groupId }))))
+            .map((file) => file.path);
+        ContentInstaller.reportError("evicted", "[ContentInstaller] The browser removed stored files of " + evicted.join(", ") + ": they load from the network until installed again.", missingPaths);
+    }
+    static onFileStored(hash) {
+        ContentInstaller.storedHashes.add(hash);
+        ContentInstaller.settleStoreWaiters(hash, ContentInstaller.storeResult("stored", null, null, null));
+        ContentInstaller.removeQueuedJob(hash);
+        const changedRoots = new Set();
+        for (const groupRef of ContentInstaller.groupsByHash.get(hash) || []) {
+            const installedGroups = groupRef.root.state.installedGroups;
+            if (installedGroups.indexOf(groupRef.groupId) >= 0)
+                continue;
+            if (!ContentInstaller.isGroupStored(groupRef.root.activeManifest, groupRef.groupId))
+                continue;
+            installedGroups.push(groupRef.groupId);
+            changedRoots.add(groupRef.root);
+        }
+        if (changedRoots.size > 0) {
+            if (ContentInstaller.state.isLeader)
+                changedRoots.forEach((root) => { void ContentInstaller.writeRootState(root); });
+            ContentInstaller.updateTotalsState();
+        }
+        ContentInstaller.settleFinishedCalls();
+        ContentInstaller.emitProgress(false);
+        ContentInstaller.finishSessionIfDrained();
+    }
+    static normalizeGroupIds(groupIds) {
+        return (groupIds != null && groupIds.length > 0) ? groupIds.slice() : null;
+    }
+    static resolveGroups(groupIds, includeShell) {
+        const groupRefs = [];
+        const everyGroup = (groupIds == null || groupIds.length === 0);
+        if (everyGroup) {
+            ContentInstaller.roots.forEach((root) => {
+                if (root.activeManifest == null || (root.state.isAppShell && !includeShell))
+                    return;
+                for (const groupId of Object.keys(root.activeManifest.groups))
+                    groupRefs.push({ root: root, groupId: groupId });
+            });
+            return groupRefs;
+        }
+        for (const groupId of groupIds) {
+            ContentInstaller.roots.forEach((root) => {
+                if (root.activeManifest != null && root.activeManifest.groups[groupId] != null)
+                    groupRefs.push({ root: root, groupId: groupId });
+            });
+        }
+        return groupRefs;
+    }
+    static groupFiles(groupRefs) {
+        const files = [];
+        for (const groupRef of groupRefs)
+            ContentInstaller.appendGroupFiles(files, groupRef.root.state.rootKey, groupRef.root.activeManifest, groupRef.groupId);
+        return files;
+    }
+    static appendGroupFiles(files, rootKey, manifest, groupId) {
+        const group = manifest.groups[groupId];
+        if (group == null)
+            return;
+        for (const path of group.files) {
+            const entry = manifest.files[path];
+            if (entry != null)
+                files.push({ rootKey: rootKey, version: manifest.version, path: path, entry: entry, groupId: groupId });
+        }
+    }
+    static missingFiles(files) {
+        const seen = new Set();
+        return files.filter((file) => {
+            const hash = file.entry.hash;
+            if (seen.has(hash) || ContentInstaller.storedHashes.has(hash))
+                return false;
+            seen.add(hash);
+            return true;
+        });
+    }
+    static groupStatus(groupRef) {
+        const files = ContentInstaller.groupFiles([groupRef]);
+        const storedFiles = files.filter((file) => ContentInstaller.storedHashes.has(file.entry.hash));
+        const graphics = ContentInstaller.graphicsStatusOf(groupRef);
+        return {
+            rootKey: groupRef.root.state.rootKey,
+            groupId: groupRef.groupId,
+            installed: groupRef.root.state.installedGroups.indexOf(groupRef.groupId) >= 0,
+            totalBytes: ContentInstaller.sumSizes(files),
+            storedBytes: ContentInstaller.sumSizes(storedFiles),
+            fileCount: files.length,
+            storedFileCount: storedFiles.length,
+            graphics: graphics,
+            graphicsPrepared: graphics === "prepared",
+            graphicsStale: graphics === "stale",
+        };
+    }
+    static sumSizes(files) {
+        const seen = new Set();
+        let total = 0;
+        for (const file of files) {
+            if (seen.has(file.entry.hash))
+                continue;
+            seen.add(file.entry.hash);
+            total += file.entry.size;
+        }
+        return total;
+    }
+    static findSceneGroup(sceneUrl) {
+        const absolute = ContentInstaller.stripQueryAndHash(ContentInstaller.absoluteUrl(sceneUrl));
+        let bestRoot = null;
+        for (const root of Array.from(ContentInstaller.roots.values())) {
+            if (root.activeManifest == null || !absolute.startsWith(root.state.baseUrl))
+                continue;
+            if (bestRoot == null || root.state.baseUrl.length > bestRoot.state.baseUrl.length)
+                bestRoot = root;
+        }
+        if (bestRoot == null)
+            return null;
+        const manifest = bestRoot.activeManifest;
+        const relativePath = decodeURIComponent(absolute.substring(bestRoot.state.baseUrl.length));
+        for (const [groupId, group] of Object.entries(manifest.groups)) {
+            if (group.scene === relativePath)
+                return { root: bestRoot, groupId: groupId };
+        }
+        const groupId = ContentInstaller.GroupIdFromSceneFile(absolute);
+        return (manifest.groups[groupId] != null) ? { root: bestRoot, groupId: groupId } : null;
+    }
+    static async installAsLeader(groupIds, background, requestId, skipPendingRoots = false) {
+        const resolvedRefs = ContentInstaller.resolveGroups(groupIds, true);
+        const groupRefs = resolvedRefs.filter((groupRef) => ContentInstaller.installsFromActiveVersion(groupRef.root, skipPendingRoots));
+        const everyGroupSkipped = resolvedRefs.length > 0 && groupRefs.length === 0;
+        if ((groupIds != null && resolvedRefs.length === 0) || everyGroupSkipped)
+            return ContentInstaller.answerRequest(requestId, false);
+        if (!background)
+            await ContentInstaller.markRequested(groupRefs);
+        const files = ContentInstaller.groupFiles(groupRefs);
+        const missing = ContentInstaller.missingFiles(files);
+        if (missing.length === 0) {
+            ContentInstaller.roots.forEach((root) => { ContentInstaller.recomputeInstalledGroups(root, false); });
+            ContentInstaller.updateTotalsState();
+            return ContentInstaller.answerRequest(requestId, true);
+        }
+        if (!background)
+            await ContentInstaller.RequestPersistentStorage();
+        const estimate = await ContentInstaller.estimateFor(missing);
+        if (!estimate.fits) {
+            ContentInstaller.reportQuotaShortfall(estimate);
+            return ContentInstaller.answerRequest(requestId, false);
+        }
+        return ContentInstaller.submitCall(files, missing, background, requestId);
+    }
+    static async markRequested(groupRefs) {
+        const changedRoots = new Set();
+        for (const groupRef of groupRefs) {
+            if (groupRef.root.state.requestedGroups.indexOf(groupRef.groupId) >= 0)
+                continue;
+            groupRef.root.state.requestedGroups.push(groupRef.groupId);
+            changedRoots.add(groupRef.root);
+        }
+        for (const root of Array.from(changedRoots))
+            await ContentInstaller.writeRootState(root);
+    }
+    static answerRequest(requestId, success) {
+        if (requestId != null)
+            ContentInstaller.postToChannel({ type: "install-finished", requestId: requestId, success: success });
+        return success;
+    }
+    static submitCall(files, missing, background, requestId) {
+        return new Promise((resolve) => {
+            const hashes = new Set(files.map((file) => file.entry.hash));
+            ContentInstaller.installCalls.push({ hashes: hashes, requestId: requestId, resolve: resolve });
+            ContentInstaller.addToSession(files);
+            const jobs = missing.map((file) => ContentInstaller.createJob(file, background));
+            for (const job of jobs)
+                ContentInstaller.failedHashes.delete(job.hash);
+            ContentInstaller.enqueue(jobs, background);
+            ContentInstaller.setState({ installing: true });
+            ContentInstaller.pumpQueue();
+            ContentInstaller.settleFinishedCalls();
+            ContentInstaller.finishSessionIfDrained();
+        });
+    }
+    static createJob(file, background) {
+        return { rootKey: file.rootKey, version: file.version, path: file.path, entry: file.entry, groupId: file.groupId, hash: file.entry.hash, background: background, attempt: 0 };
+    }
+    static enqueue(jobs, background) {
+        const additions = [];
+        for (const job of jobs) {
+            const running = ContentInstaller.inFlight.get(job.hash);
+            if (running != null) {
+                if (!background)
+                    running.job.background = false;
+                continue;
+            }
+            const retrying = ContentInstaller.retryWaits.get(job.hash);
+            if (retrying != null) {
+                if (!background)
+                    retrying.job.background = false;
+                continue;
+            }
+            const queuedIndex = ContentInstaller.queue.findIndex((queued) => queued.hash === job.hash);
+            if (queuedIndex < 0) {
+                additions.push(job);
+                continue;
+            }
+            const queuedJob = ContentInstaller.queue[queuedIndex];
+            if (!queuedJob.background)
+                continue;
+            ContentInstaller.queue.splice(queuedIndex, 1);
+            queuedJob.background = background;
+            additions.push(queuedJob);
+        }
+        ContentInstaller.queue.splice(ContentInstaller.firstBackgroundIndex(), 0, ...additions);
+    }
+    static firstBackgroundIndex() {
+        const index = ContentInstaller.queue.findIndex((job) => job.background);
+        return (index < 0) ? ContentInstaller.queue.length : index;
+    }
+    static requeueFront(job) {
+        const index = job.background ? ContentInstaller.firstBackgroundIndex() : 0;
+        ContentInstaller.queue.splice(index, 0, job);
+    }
+    static prioritiseGroup(groupRef) {
+        const groupHashes = new Set(ContentInstaller.groupFiles([groupRef]).map((file) => file.entry.hash));
+        const front = [];
+        const rest = [];
+        for (const job of ContentInstaller.queue) {
+            if (!groupHashes.has(job.hash)) {
+                rest.push(job);
+                continue;
+            }
+            job.background = false;
+            front.push(job);
+        }
+        ContentInstaller.queue = front.concat(rest);
+    }
+    static removeQueuedJob(hash) {
+        const index = ContentInstaller.queue.findIndex((job) => job.hash === hash);
+        if (index >= 0)
+            ContentInstaller.queue.splice(index, 1);
+        const retry = ContentInstaller.retryWaits.get(hash);
+        if (retry == null)
+            return;
+        clearTimeout(retry.timer);
+        ContentInstaller.retryWaits.delete(hash);
+    }
+    static pumpQueue() {
+        if (!ContentInstaller.state.isLeader || ContentInstaller.state.paused)
+            return;
+        const limit = ContentInstaller.busy ? ContentInstaller.BUSY_CONCURRENCY : ContentInstaller.IDLE_CONCURRENCY;
+        while (ContentInstaller.inFlight.size < limit) {
+            const index = ContentInstaller.queue.findIndex((job) => !(ContentInstaller.busy && job.background));
+            if (index < 0)
+                return;
+            const job = ContentInstaller.queue.splice(index, 1)[0];
+            ContentInstaller.startDownload(job);
+        }
+    }
+    static startDownload(job) {
+        const download = { job: job, controller: new AbortController(), decodedBytesRead: 0, abortReason: null };
+        ContentInstaller.inFlight.set(job.hash, download);
+        void ContentInstaller.downloadFile(download).then((result) => { ContentInstaller.finishDownload(download, result); });
+    }
+    static async downloadFile(download) {
+        const job = download.job;
+        const verdict = ContentInstaller.awaitStoreResult(job.hash);
+        try {
+            const response = await fetch(ContentInstaller.downloadUrl(job), { signal: download.controller.signal });
+            await ContentInstaller.readBody(response, download);
+        }
+        catch {
+        }
+        if (download.controller.signal.aborted)
+            return ContentInstaller.storeResult("aborted", null, null, null);
+        return verdict;
+    }
+    static downloadUrl(job) {
+        const root = ContentInstaller.roots.get(job.rootKey);
+        const baseUrl = (root != null) ? root.state.baseUrl : ContentInstaller.folderOf(job.rootKey);
+        const encodedPath = job.path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+        return baseUrl + encodedPath + "?" + ContentInstaller.INSTALL_MARKER_PARAMETER + "=" + encodeURIComponent(job.version) + "&" + ContentInstaller.ATTEMPT_PARAMETER + "=" + job.attempt;
+    }
+    static async readBody(response, download) {
+        if (response.body == null)
+            return;
+        const reader = response.body.getReader();
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                return;
+            download.decodedBytesRead += chunk.value.byteLength;
+            ContentInstaller.recordPartial(download);
+            ContentInstaller.emitProgress(false);
+        }
+    }
+    static awaitStoreResult(hash) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => { void ContentInstaller.confirmFromStore(hash); }, ContentInstaller.STORE_CONFIRM_TIMEOUT_MS);
+            const waiters = ContentInstaller.storeWaiters.get(hash) || [];
+            waiters.push({ resolve: resolve, timer: timer });
+            ContentInstaller.storeWaiters.set(hash, waiters);
+        });
+    }
+    static async confirmFromStore(hash) {
+        const stored = await ContentInstaller.isHashStored(hash);
+        const result = stored ? ContentInstaller.storeResult("stored", null, null, null)
+            : ContentInstaller.storeResult("failed", "network", null, "no answer from the content worker");
+        ContentInstaller.settleStoreWaiters(hash, result);
+    }
+    static settleStoreWaiters(hash, result) {
+        const waiters = ContentInstaller.storeWaiters.get(hash);
+        if (waiters == null)
+            return;
+        ContentInstaller.storeWaiters.delete(hash);
+        for (const waiter of waiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve(result);
+        }
+    }
+    static storeResult(outcome, reason, status, detail) {
+        return { outcome: outcome, reason: reason, status: status, detail: detail };
+    }
+    static finishDownload(download, result) {
+        const job = download.job;
+        if (ContentInstaller.inFlight.get(job.hash) === download)
+            ContentInstaller.inFlight.delete(job.hash);
+        if (result.outcome === "stored")
+            ContentInstaller.onFileStored(job.hash);
+        else if (result.outcome === "failed")
+            ContentInstaller.handleDownloadFailure(job, result);
+        else if (download.abortReason === "pause")
+            ContentInstaller.requeueFront(job);
+        ContentInstaller.settleFinishedCalls();
+        ContentInstaller.emitProgress(false);
+        ContentInstaller.pumpQueue();
+        ContentInstaller.finishSessionIfDrained();
+    }
+    static handleDownloadFailure(job, result) {
+        if (result.reason === "cors") {
+            ContentInstaller.stopForCors(job);
+            return;
+        }
+        if (result.detail != null && result.detail.indexOf("QuotaExceeded") >= 0) {
+            ContentInstaller.requeueFront(job);
+            ContentInstaller.reportError("quota", "[ContentInstaller] Storage is full while storing " + job.path + ": installing is paused.", [job.path]);
+            ContentInstaller.Pause();
+            return;
+        }
+        if (job.attempt + 1 < ContentInstaller.MAX_ATTEMPTS) {
+            ContentInstaller.scheduleRetry(job);
+            return;
+        }
+        ContentInstaller.failedHashes.add(job.hash);
+        if (result.reason === "mismatch") {
+            void ContentInstaller.reportInstallMismatch(job);
+            return;
+        }
+        ContentInstaller.reportError("network", "[ContentInstaller] " + job.path + " could not be downloaded (" + ContentInstaller.describeFailure(result) + "): not stored.", [job.path]);
+    }
+    static async reportInstallMismatch(job) {
+        const reported = await ContentInstaller.recheckAfterMismatch(job.rootKey);
+        if (reported)
+            return;
+        ContentInstaller.reportError("mismatch", "[ContentInstaller] The server's " + job.path + " does not match its manifest: not stored.", [job.path]);
+    }
+    static describeFailure(result) {
+        if (result.status != null)
+            return "HTTP " + result.status;
+        if (result.detail != null)
+            return result.detail;
+        return (result.reason != null) ? result.reason : "network";
+    }
+    static scheduleRetry(job) {
+        const delay = ContentInstaller.RETRY_DELAYS_MS[job.attempt];
+        job.attempt += 1;
+        const timer = setTimeout(() => {
+            ContentInstaller.retryWaits.delete(job.hash);
+            ContentInstaller.requeueFront(job);
+            ContentInstaller.pumpQueue();
+        }, delay);
+        ContentInstaller.retryWaits.set(job.hash, { job: job, timer: timer });
+    }
+    static clearRetryWaits() {
+        ContentInstaller.retryWaits.forEach((retry) => { clearTimeout(retry.timer); });
+        ContentInstaller.retryWaits.clear();
+    }
+    static stopForCors(job) {
+        const root = ContentInstaller.roots.get(job.rootKey);
+        const assetOrigin = new URL((root != null) ? root.state.baseUrl : job.rootKey).origin;
+        ContentInstaller.reportError("cors", "[ContentInstaller] " + assetOrigin + " sends no CORS headers for " + location.origin + ": nothing is stored.", []);
+        ContentInstaller.failedHashes.add(job.hash);
+        for (const queued of ContentInstaller.queue)
+            ContentInstaller.failedHashes.add(queued.hash);
+        ContentInstaller.retryWaits.forEach((retry) => { ContentInstaller.failedHashes.add(retry.job.hash); });
+        ContentInstaller.inFlight.forEach((running) => { ContentInstaller.failedHashes.add(running.job.hash); });
+        ContentInstaller.queue = [];
+        ContentInstaller.clearRetryWaits();
+        ContentInstaller.abortInFlight("cancel");
+        ContentInstaller.settleFinishedCalls();
+    }
+    static abortInFlight(reason) {
+        ContentInstaller.inFlight.forEach((download) => {
+            download.abortReason = reason;
+            download.controller.abort();
+            ContentInstaller.settleStoreWaiters(download.job.hash, ContentInstaller.storeResult("aborted", null, null, null));
+        });
+    }
+    static settleFinishedCalls() {
+        const finished = [];
+        const waiting = [];
+        for (const call of ContentInstaller.installCalls) {
+            const settled = Array.from(call.hashes).every((hash) => ContentInstaller.storedHashes.has(hash) || ContentInstaller.failedHashes.has(hash));
+            if (settled)
+                finished.push(call);
+            else
+                waiting.push(call);
+        }
+        if (finished.length === 0)
+            return;
+        ContentInstaller.installCalls = waiting;
+        void ContentInstaller.completeCalls(finished, false);
+    }
+    static async completeCalls(calls, cancelled) {
+        if (calls.length === 0)
+            return;
+        ContentInstaller.roots.forEach((root) => { ContentInstaller.recomputeInstalledGroups(root, false); });
+        if (ContentInstaller.state.isLeader) {
+            for (const root of Array.from(ContentInstaller.roots.values()))
+                await ContentInstaller.writeRootState(root);
+        }
+        ContentInstaller.updateTotalsState();
+        for (const call of calls) {
+            const success = !cancelled && Array.from(call.hashes).every((hash) => ContentInstaller.storedHashes.has(hash));
+            call.resolve(success);
+            if (call.requestId != null)
+                ContentInstaller.postToChannel({ type: "install-finished", requestId: call.requestId, success: success });
+        }
+    }
+    static addToSession(files) {
+        if (ContentInstaller.progress == null) {
+            ContentInstaller.progress = { sizeByHash: new Map(), partialByHash: new Map(), hashesByGroup: new Map(), lastEmitTime: -Infinity, lastSpeedTime: null, lastSpeedBytes: 0, bytesPerSecond: 0 };
+        }
+        const session = ContentInstaller.progress;
+        for (const file of files) {
+            session.sizeByHash.set(file.entry.hash, file.entry.size);
+            const groupHashes = session.hashesByGroup.get(file.groupId) || new Set();
+            groupHashes.add(file.entry.hash);
+            session.hashesByGroup.set(file.groupId, groupHashes);
+        }
+    }
+    static recordPartial(download) {
+        const session = ContentInstaller.progress;
+        if (session == null)
+            return;
+        const entry = download.job.entry;
+        const share = (entry.contentSize > 0) ? Math.min(1, download.decodedBytesRead / entry.contentSize) : 0;
+        const estimate = share * entry.size;
+        const previous = session.partialByHash.get(download.job.hash) || 0;
+        if (estimate > previous)
+            session.partialByHash.set(download.job.hash, estimate);
+    }
+    static completedBytesOf(session, hash) {
+        if (ContentInstaller.storedHashes.has(hash))
+            return session.sizeByHash.get(hash) || 0;
+        return session.partialByHash.get(hash) || 0;
+    }
+    static buildProgress(session) {
+        let totalBytes = 0;
+        let completedBytes = 0;
+        let completedFileCount = 0;
+        session.sizeByHash.forEach((size, hash) => {
+            totalBytes += size;
+            completedBytes += ContentInstaller.completedBytesOf(session, hash);
+            if (ContentInstaller.storedHashes.has(hash))
+                completedFileCount += 1;
+        });
+        const groupProgress = {};
+        session.hashesByGroup.forEach((hashes, groupId) => {
+            let groupTotal = 0;
+            let groupCompleted = 0;
+            hashes.forEach((hash) => {
+                groupTotal += session.sizeByHash.get(hash) || 0;
+                groupCompleted += ContentInstaller.completedBytesOf(session, hash);
+            });
+            groupProgress[groupId] = { totalBytes: groupTotal, completedBytes: Math.min(groupTotal, groupCompleted) };
+        });
+        ContentInstaller.sampleSpeed(session, completedBytes);
+        const remainingBytes = Math.max(0, totalBytes - completedBytes);
+        const firstRunning = ContentInstaller.inFlight.values().next().value;
+        return {
+            totalBytes: totalBytes,
+            completedBytes: Math.min(totalBytes, completedBytes),
+            fraction: (totalBytes > 0) ? Math.min(1, completedBytes / totalBytes) : 1,
+            fileCount: session.sizeByHash.size,
+            completedFileCount: completedFileCount,
+            bytesPerSecond: session.bytesPerSecond,
+            secondsRemaining: (session.bytesPerSecond > 0) ? remainingBytes / session.bytesPerSecond : null,
+            currentGroupId: (firstRunning != null) ? firstRunning.job.groupId : null,
+            groupProgress: groupProgress,
+            phase: "download",
+        };
+    }
+    static sampleSpeed(session, completedBytes) {
+        const now = ContentInstaller.Clock();
+        if (session.lastSpeedTime == null) {
+            session.lastSpeedTime = now;
+            session.lastSpeedBytes = completedBytes;
+            return;
+        }
+        const elapsedSeconds = (now - session.lastSpeedTime) / ContentInstaller.MILLISECONDS_PER_SECOND;
+        if (elapsedSeconds <= 0)
+            return;
+        const sampleRate = (completedBytes - session.lastSpeedBytes) / elapsedSeconds;
+        const smoothing = 1 - Math.exp(-elapsedSeconds / ContentInstaller.SPEED_TIME_CONSTANT_SECONDS);
+        session.bytesPerSecond = Math.max(0, session.bytesPerSecond + (sampleRate - session.bytesPerSecond) * smoothing);
+        session.lastSpeedTime = now;
+        session.lastSpeedBytes = completedBytes;
+    }
+    static emitProgress(force) {
+        const session = ContentInstaller.progress;
+        if (session == null)
+            return;
+        const now = ContentInstaller.Clock();
+        if (!force && now - session.lastEmitTime < ContentInstaller.PROGRESS_INTERVAL_MS)
+            return;
+        session.lastEmitTime = now;
+        const report = ContentInstaller.buildProgress(session);
+        ContentInstaller.OnProgressObservable.notifyObservers(report);
+        if (ContentInstaller.state.isLeader)
+            ContentInstaller.postToChannel({ type: "progress", progress: report });
+    }
+    static finishSessionIfDrained() {
+        if (ContentInstaller.progress == null)
+            return;
+        if (ContentInstaller.queue.length > 0 || ContentInstaller.inFlight.size > 0 || ContentInstaller.retryWaits.size > 0)
+            return;
+        ContentInstaller.endSession();
+    }
+    static endSession() {
+        if (ContentInstaller.progress != null)
+            ContentInstaller.emitProgress(true);
+        ContentInstaller.progress = null;
+        ContentInstaller.setState({ installing: false });
+    }
+    static async installThenPrepareAsLeader(groupIds, background, prepareGraphics, requestId) {
+        if (!prepareGraphics)
+            return ContentInstaller.installAsLeader(groupIds, background, requestId);
+        const cancelsBefore = ContentInstaller.cancelCount;
+        const downloaded = await ContentInstaller.installAsLeader(groupIds, background, null);
+        if (ContentInstaller.cancelCount !== cancelsBefore)
+            return ContentInstaller.answerRequest(requestId, downloaded);
+        const installedIds = ContentInstaller.sceneGroupRefs(groupIds)
+            .filter((groupRef) => ContentInstaller.isGroupInstalled(groupRef))
+            .map((groupRef) => groupRef.groupId);
+        if (installedIds.length > 0)
+            await ContentInstaller.startGraphicsStep(installedIds, background, false);
+        return ContentInstaller.answerRequest(requestId, downloaded);
+    }
+    static async prepareGraphicsAsLeader(groupIds, background, force, requestId) {
+        const prepared = await ContentInstaller.startGraphicsStep(groupIds, background, force);
+        return ContentInstaller.answerRequest(requestId, prepared);
+    }
+    static startGraphicsStep(groupIds, background, force) {
+        if (ContentInstaller.graphicsRun != null)
+            return ContentInstaller.graphicsRun;
+        const preparer = ContentInstaller.graphicsPreparer;
+        if (preparer == null || ContentInstaller.graphicsUnavailable)
+            return Promise.resolve(false);
+        const candidates = (groupIds == null)
+            ? ContentInstaller.sceneGroupRefs(null).filter((groupRef) => ContentInstaller.isGroupInstalled(groupRef))
+            : ContentInstaller.sceneGroupRefs(groupIds);
+        if (groupIds != null && candidates.length === 0)
+            return Promise.resolve(false);
+        const groupRefs = force ? candidates : candidates.filter((groupRef) => ContentInstaller.graphicsStatusOf(groupRef) !== "prepared");
+        if (groupRefs.length === 0)
+            return Promise.resolve(true);
+        const run = ContentInstaller.runGraphicsStep(preparer, groupRefs, background).finally(() => { ContentInstaller.graphicsRun = null; });
+        ContentInstaller.graphicsRun = run;
+        return run;
+    }
+    static async runGraphicsStep(preparer, groupRefs, background) {
+        ContentInstaller.graphicsCancelled = false;
+        ContentInstaller.graphicsSession = { total: groupRefs.length, completed: 0, groupFraction: 0, currentGroupId: null, lastEmitTime: -Infinity };
+        ContentInstaller.setState({ graphicsPreparing: true });
+        let allPrepared = true;
+        try {
+            for (const groupRef of groupRefs) {
+                await ContentInstaller.waitForGraphicsTurn(background);
+                if (ContentInstaller.graphicsCancelled) {
+                    allPrepared = false;
+                    break;
+                }
+                const outcome = await ContentInstaller.prepareGroupGraphics(preparer, groupRef);
+                if (outcome !== "prepared")
+                    allPrepared = false;
+                if (outcome === "cancelled" || outcome === "unavailable")
+                    break;
+            }
+        }
+        finally {
+            ContentInstaller.finishGraphicsStep(preparer);
+        }
+        return allPrepared;
+    }
+    static async prepareGroupGraphics(preparer, groupRef) {
+        const session = ContentInstaller.graphicsSession;
+        session.currentGroupId = groupRef.groupId;
+        session.groupFraction = 0;
+        ContentInstaller.emitGraphicsProgress(true);
+        const onProgress = (fraction) => {
+            session.groupFraction = Math.max(session.groupFraction, Math.min(1, fraction));
+            ContentInstaller.emitGraphicsProgress(false);
+        };
+        let failure = null;
+        try {
+            await preparer.prepareSceneAsync(ContentInstaller.groupSceneUrl(groupRef), () => ContentInstaller.graphicsCancelled, onProgress);
+        }
+        catch (error) {
+            if (ContentInstaller.isGraphicsUnavailableError(error)) {
+                ContentInstaller.markGraphicsUnavailable(error);
+                return "unavailable";
+            }
+            failure = (error != null && typeof error.message === "string") ? error.message : String(error);
+        }
+        if (ContentInstaller.graphicsCancelled)
+            return "cancelled";
+        if (failure != null)
+            console.warn("[ContentInstaller] The graphics of " + groupRef.groupId + " could not be prepared (" + failure + "): it loads as before.");
+        await ContentInstaller.recordGraphics(preparer, groupRef, (failure == null) ? "prepared" : "failed", failure);
+        session.completed += 1;
+        session.groupFraction = 0;
+        ContentInstaller.emitGraphicsProgress(false);
+        return (failure == null) ? "prepared" : "failed";
+    }
+    static async waitForGraphicsTurn(background) {
+        const isHeld = () => !ContentInstaller.graphicsCancelled && (ContentInstaller.state.paused || ContentInstaller.state.installing || (background && ContentInstaller.busy));
+        while (isHeld())
+            await new Promise((resolve) => { ContentInstaller.graphicsWaiters.push(resolve); });
+    }
+    static wakeGraphicsWaiters() {
+        if (ContentInstaller.graphicsWaiters.length === 0)
+            return;
+        const waiters = ContentInstaller.graphicsWaiters;
+        ContentInstaller.graphicsWaiters = [];
+        for (const wake of waiters)
+            wake();
+    }
+    static finishGraphicsStep(preparer) {
+        const session = ContentInstaller.graphicsSession;
+        if (session != null) {
+            session.currentGroupId = null;
+            session.groupFraction = 0;
+            ContentInstaller.emitGraphicsProgress(true);
+        }
+        ContentInstaller.graphicsSession = null;
+        if (typeof preparer.release === "function") {
+            try {
+                preparer.release();
+            }
+            catch (error) {
+                console.warn("[ContentInstaller] The graphics preparer could not be released: " + String(error));
+            }
+        }
+        ContentInstaller.setState({ graphicsPreparing: false });
+        ContentInstaller.updateTotalsState();
+    }
+    static async recordGraphics(preparer, groupRef, outcome, error) {
+        const root = groupRef.root;
+        const record = {
+            manifestVersion: root.state.activeVersion, runtimeVersion: preparer.runtimeVersion, babylonVersion: preparer.babylonVersion,
+            engineKey: preparer.engineKey, outcome: outcome, error: error,
+        };
+        root.state.graphics[groupRef.groupId] = record;
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.writeRootState(root);
+        ContentInstaller.postToChannel({ type: "graphics-recorded", rootKey: root.state.rootKey, groupId: groupRef.groupId, graphicsRecord: record });
+        ContentInstaller.updateTotalsState();
+    }
+    static takeGraphicsRecord(message) {
+        const root = (message.rootKey != null) ? ContentInstaller.roots.get(message.rootKey) : undefined;
+        if (root == null || message.groupId == null || message.graphicsRecord == null)
+            return;
+        root.state.graphics[message.groupId] = message.graphicsRecord;
+    }
+    static emitGraphicsProgress(force) {
+        const session = ContentInstaller.graphicsSession;
+        if (session == null)
+            return;
+        const now = ContentInstaller.Clock();
+        if (!force && now - session.lastEmitTime < ContentInstaller.PROGRESS_INTERVAL_MS)
+            return;
+        session.lastEmitTime = now;
+        const finished = Math.min(session.total, session.completed + session.groupFraction);
+        const report = {
+            totalBytes: 0, completedBytes: 0, fraction: (session.total > 0) ? finished / session.total : 1, fileCount: 0, completedFileCount: 0,
+            bytesPerSecond: 0, secondsRemaining: null, currentGroupId: session.currentGroupId, groupProgress: {},
+            phase: "graphics", graphicsCurrent: Math.min(session.total, session.completed + 1), graphicsCompleted: session.completed, graphicsTotal: session.total,
+        };
+        ContentInstaller.OnProgressObservable.notifyObservers(report);
+        if (ContentInstaller.state.isLeader)
+            ContentInstaller.postToChannel({ type: "progress", progress: report });
+    }
+    static updateGraphicsState() {
+        if (!ContentInstaller.state.isLeader)
+            return;
+        const sceneGroups = ContentInstaller.sceneGroupRefs(null).filter((groupRef) => ContentInstaller.isGroupInstalled(groupRef));
+        const preparedCount = sceneGroups.filter((groupRef) => ContentInstaller.graphicsStatusOf(groupRef) === "prepared").length;
+        ContentInstaller.setState({
+            graphicsAvailable: ContentInstaller.graphicsPreparer != null && !ContentInstaller.graphicsUnavailable,
+            graphicsNeeded: preparedCount < sceneGroups.length,
+            graphicsPreparedCount: preparedCount,
+            graphicsGroupCount: sceneGroups.length,
+        });
+    }
+    static graphicsStatusOf(groupRef) {
+        if (!ContentInstaller.hasSceneFile(groupRef))
+            return "none";
+        const record = groupRef.root.state.graphics[groupRef.groupId];
+        if (record == null)
+            return "none";
+        if (!ContentInstaller.isGraphicsRecordCurrent(groupRef.root, record))
+            return "stale";
+        return (record.outcome === "prepared") ? "prepared" : "failed";
+    }
+    static isGraphicsRecordCurrent(root, record) {
+        if (record.manifestVersion !== root.state.activeVersion || record.gpuCacheLost === true)
+            return false;
+        const preparer = ContentInstaller.graphicsPreparer;
+        if (preparer == null)
+            return true;
+        return record.runtimeVersion === preparer.runtimeVersion && record.babylonVersion === preparer.babylonVersion && record.engineKey === preparer.engineKey;
+    }
+    static sceneGroupRefs(groupIds) {
+        return ContentInstaller.resolveGroups(groupIds, false)
+            .filter((groupRef) => !groupRef.root.state.isAppShell && ContentInstaller.hasSceneFile(groupRef));
+    }
+    static hasSceneFile(groupRef) {
+        const group = (groupRef.root.activeManifest != null) ? groupRef.root.activeManifest.groups[groupRef.groupId] : undefined;
+        if (group == null || typeof group.scene !== "string")
+            return false;
+        const scene = group.scene.toLowerCase();
+        return ContentInstaller.SCENE_FILE_SUFFIXES.some((suffix) => scene.endsWith(suffix));
+    }
+    static isGroupInstalled(groupRef) {
+        return groupRef.root.state.installedGroups.indexOf(groupRef.groupId) >= 0;
+    }
+    static groupSceneUrl(groupRef) {
+        const scenePath = groupRef.root.activeManifest.groups[groupRef.groupId].scene;
+        return groupRef.root.state.baseUrl + scenePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+    }
+    static isGraphicsUnavailableError(error) {
+        return error != null && typeof error === "object" && error.graphicsUnavailable === true;
+    }
+    static markGraphicsUnavailable(error) {
+        if (!ContentInstaller.graphicsUnavailable)
+            console.warn("[ContentInstaller] Prepare graphics is unavailable here (" + String(error.message || error) + "): scenes load as before.");
+        ContentInstaller.graphicsUnavailable = true;
+        ContentInstaller.updateTotalsState();
+    }
+    static async estimateFor(missingFiles) {
+        const neededBytes = missingFiles.reduce((total, file) => total + file.entry.contentSize, 0);
+        let quotaBytes = null;
+        let usageBytes = null;
+        try {
+            if (typeof navigator !== "undefined" && navigator.storage != null && typeof navigator.storage.estimate === "function") {
+                const estimate = await navigator.storage.estimate();
+                quotaBytes = (estimate.quota != null) ? estimate.quota : null;
+                usageBytes = (estimate.usage != null) ? estimate.usage : null;
+            }
+        }
+        catch {
+            quotaBytes = null;
+            usageBytes = null;
+        }
+        const freeBytes = (quotaBytes != null && usageBytes != null) ? quotaBytes - usageBytes : null;
+        const fits = freeBytes == null || freeBytes >= neededBytes * ContentInstaller.QUOTA_SAFETY_FACTOR;
+        return { neededBytes: neededBytes, freeBytes: freeBytes, quotaBytes: quotaBytes, usageBytes: usageBytes, fits: fits };
+    }
+    static reportQuotaShortfall(estimate) {
+        const neededMegabytes = (estimate.neededBytes / ContentInstaller.BYTES_PER_MEGABYTE).toFixed(1);
+        const freeMegabytes = ((estimate.freeBytes || 0) / ContentInstaller.BYTES_PER_MEGABYTE).toFixed(1);
+        ContentInstaller.reportError("quota", "[ContentInstaller] Installing needs " + neededMegabytes + " MB but only " + freeMegabytes + " MB is free: nothing was downloaded.", []);
+    }
+    static rootsWithPending() {
+        return Array.from(ContentInstaller.roots.values()).filter((root) => root.pendingManifest != null);
+    }
+    static updateFiles(root) {
+        const files = [];
+        for (const groupId of root.state.installedGroups)
+            ContentInstaller.appendGroupFiles(files, root.state.rootKey, root.pendingManifest, groupId);
+        return ContentInstaller.missingFiles(files);
+    }
+    static isPendingReady(root) {
+        return root.pendingManifest != null && ContentInstaller.updateFiles(root).length === 0;
+    }
+    static updateInfo(root) {
+        const delta = ContentInstaller.updateFiles(root);
+        return {
+            rootKey: root.state.rootKey,
+            fromVersion: root.state.activeVersion,
+            toVersion: root.state.pendingVersion,
+            downloadBytes: ContentInstaller.sumSizes(delta),
+            fileCount: delta.length,
+        };
+    }
+    static downloadUpdateFor(pendingRoots) {
+        if (ContentInstaller.updateDownload != null)
+            return ContentInstaller.updateDownload;
+        const run = async () => {
+            const delta = [];
+            for (const root of pendingRoots)
+                delta.push(...ContentInstaller.updateFiles(root));
+            const missing = ContentInstaller.missingFiles(delta);
+            if (missing.length > 0) {
+                const estimate = await ContentInstaller.estimateFor(missing);
+                if (!estimate.fits) {
+                    ContentInstaller.reportQuotaShortfall(estimate);
+                    return false;
+                }
+                await ContentInstaller.submitCall(missing, missing, true, null);
+            }
+            ContentInstaller.updateTotalsState();
+            return pendingRoots.every((root) => ContentInstaller.isPendingReady(root));
+        };
+        ContentInstaller.updateDownload = run().finally(() => { ContentInstaller.updateDownload = null; });
+        return ContentInstaller.updateDownload;
+    }
+    static runUpdatePolicies() {
+        if (!ContentInstaller.state.isLeader)
+            return;
+        const automaticRoots = ContentInstaller.rootsWithPending()
+            .filter((root) => ContentInstaller.effectiveUpdatePolicy(root) === "automatic" && !root.state.applyOnNextLoad);
+        if (automaticRoots.length === 0)
+            return;
+        void ContentInstaller.downloadUpdateFor(automaticRoots).then(() => {
+            for (const root of automaticRoots) {
+                if (ContentInstaller.isPendingReady(root))
+                    root.state.applyOnNextLoad = true;
+            }
+            void ContentInstaller.persistRoots(false);
+            ContentInstaller.updateTotalsState();
+        });
+    }
+    static recheckAfterMismatch(rootKey) {
+        const started = ContentInstaller.mismatchRecheckedRoots.get(rootKey);
+        if (started != null)
+            return started;
+        const root = ContentInstaller.roots.get(rootKey);
+        if (ContentInstaller.state.availability !== "available" || root == null)
+            return Promise.resolve(false);
+        const recheck = ContentInstaller.runMismatchRecheck(root);
+        ContentInstaller.mismatchRecheckedRoots.set(rootKey, recheck);
+        return recheck;
+    }
+    static async runMismatchRecheck(root) {
+        const loadedFromNetworkOnly = root.state.networkOnly != null;
+        const serverManifest = await ContentInstaller.fetchManifest(root.state.rootKey);
+        if (serverManifest == null)
+            return false;
+        const activeVersion = root.state.activeVersion;
+        const reason = (serverManifest.version !== activeVersion) ? "update-pending" : "stale-server";
+        root.state.networkOnly = { reason: reason, serverVersion: serverManifest.version };
+        if (reason === "update-pending")
+            await ContentInstaller.takeServerManifest(root, serverManifest);
+        if (ContentInstaller.state.isLeader)
+            await ContentInstaller.persistRoots(false);
+        ContentInstaller.updateTotalsState();
+        ContentInstaller.runUpdatePolicies();
+        if (loadedFromNetworkOnly)
+            return true;
+        ContentInstaller.setState({ contentChangedOnServer: true });
+        ContentInstaller.publishError("server-mismatch", ContentInstaller.serverMismatchMessage(root, reason, activeVersion, serverManifest.version), []);
+        return true;
+    }
+    static serverMismatchMessage(root, reason, activeVersion, serverVersion) {
+        const baseUrl = root.state.baseUrl;
+        if (reason === "update-pending") {
+            return "[ContentInstaller] Game content changed on the server at " + baseUrl + " (version " + ContentInstaller.shortVersion(activeVersion) + " → " + ContentInstaller.shortVersion(serverVersion) + "); offering a reload.";
+        }
+        return "[ContentInstaller] The server's files at " + baseUrl + " do not match its content manifest (version " + ContentInstaller.shortVersion(serverVersion) + "); loading them from the network until a new manifest is published.";
+    }
+    static shortVersion(version) {
+        return (version != null) ? version.substring(0, ContentInstaller.VERSION_DISPLAY_LENGTH) : "none";
+    }
+    static installsFromActiveVersion(root, skipPendingRoots) {
+        if (root.state.networkOnly != null)
+            return false;
+        return !(skipPendingRoots && root.pendingManifest != null);
+    }
+    static createInitialState() {
+        return {
+            availability: "unknown", reason: null, installPolicy: "as-you-play", updatePolicy: "prompt", isLeader: false, installing: false, paused: false,
+            persisted: null, totalBytes: 0, installedBytes: 0, everythingInstalled: false, updateAvailable: null, updateReady: false, applyOnNextLoad: false,
+            shellUpdateReady: false, lastError: null, contentChangedOnServer: false, graphicsAvailable: false, graphicsPreparing: false, graphicsNeeded: false,
+            graphicsPreparedCount: 0, graphicsGroupCount: 0,
+        };
+    }
+    static createRootState(rootKey) {
+        return {
+            rootKey: rootKey, baseUrl: ContentInstaller.folderOf(rootKey), isAppShell: false, installPolicy: ContentInstaller.state.installPolicy, activeVersion: null,
+            pendingVersion: null, installedGroups: [], requestedGroups: [], applyOnNextLoad: false, updatedAt: ContentInstaller.Clock(), networkOnly: null,
+            graphics: {},
+        };
+    }
+    static updateTotalsState() {
+        const allFiles = ContentInstaller.groupFiles(ContentInstaller.resolveGroups(null, true));
+        const installedRefs = [];
+        let everythingInstalled = ContentInstaller.roots.size > 0;
+        ContentInstaller.roots.forEach((root) => {
+            if (root.activeManifest == null)
+                return;
+            for (const groupId of Object.keys(root.activeManifest.groups)) {
+                if (root.state.installedGroups.indexOf(groupId) >= 0)
+                    installedRefs.push({ root: root, groupId: groupId });
+                else
+                    everythingInstalled = false;
+            }
+        });
+        const contentPending = ContentInstaller.rootsWithPending().filter((root) => !root.state.isAppShell);
+        const shellReady = ContentInstaller.rootsWithPending().some((root) => root.state.isAppShell && ContentInstaller.isPendingReady(root));
+        ContentInstaller.setState({
+            totalBytes: ContentInstaller.sumSizes(allFiles),
+            installedBytes: ContentInstaller.sumSizes(ContentInstaller.groupFiles(installedRefs)),
+            everythingInstalled: everythingInstalled,
+            updateAvailable: (contentPending.length > 0) ? ContentInstaller.updateInfo(contentPending[0]) : null,
+            updateReady: contentPending.length > 0 && contentPending.every((root) => ContentInstaller.isPendingReady(root)),
+            applyOnNextLoad: contentPending.some((root) => root.state.applyOnNextLoad),
+            shellUpdateReady: ContentInstaller.workerUpdateWaiting || shellReady,
+        });
+        ContentInstaller.updateGraphicsState();
+    }
+    static setState(changes) {
+        const current = ContentInstaller.state;
+        const keys = Object.keys(changes);
+        const changed = keys.some((key) => !ContentInstaller.valuesEqual(current[key], changes[key]));
+        if (!changed)
+            return;
+        ContentInstaller.state = { ...current, ...changes };
+        ContentInstaller.OnStateChangedObservable.notifyObservers(ContentInstaller.GetState());
+        if (ContentInstaller.state.isLeader)
+            ContentInstaller.postToChannel({ type: "state", state: ContentInstaller.state });
+        ContentInstaller.wakeGraphicsWaiters();
+    }
+    static valuesEqual(first, second) {
+        if (first === second)
+            return true;
+        if (first == null || second == null || typeof first !== "object" || typeof second !== "object")
+            return false;
+        const firstRecord = first;
+        const secondRecord = second;
+        const firstKeys = Object.keys(firstRecord);
+        if (firstKeys.length !== Object.keys(secondRecord).length)
+            return false;
+        return firstKeys.every((key) => firstRecord[key] === secondRecord[key]);
+    }
+    static reportError(kind, message, paths) {
+        const key = kind + "\n" + paths.slice().sort().join("\n");
+        if (ContentInstaller.reportedErrors.has(key))
+            return;
+        ContentInstaller.reportedErrors.add(key);
+        ContentInstaller.publishError(kind, message, paths);
+    }
+    static publishError(kind, message, paths) {
+        console.warn(message);
+        const error = { kind: kind, message: message, paths: paths.slice() };
+        ContentInstaller.setState({ lastError: error });
+        ContentInstaller.OnErrorObservable.notifyObservers(error);
+    }
+    static handleChannelMessage(message) {
+        if (message == null || typeof message.type !== "string")
+            return;
+        const isLeader = ContentInstaller.state.isLeader;
+        switch (message.type) {
+            case "file-stored":
+                if (message.hash != null)
+                    ContentInstaller.onFileStored(message.hash);
+                return;
+            case "file-failed":
+                if (message.hash != null)
+                    ContentInstaller.settleStoreWaiters(message.hash, ContentInstaller.storeResult("failed", message.reason || "network", (message.status != null) ? message.status : null, message.message || null));
+                if (message.reason === "mismatch" && typeof message.rootKey === "string")
+                    void ContentInstaller.recheckAfterMismatch(message.rootKey);
+                return;
+            case "state":
+                if (!isLeader && message.state != null)
+                    ContentInstaller.mirrorLeaderState(message.state);
+                return;
+            case "progress":
+                if (!isLeader && message.progress != null)
+                    ContentInstaller.OnProgressObservable.notifyObservers(message.progress);
+                return;
+            case "install-finished":
+                ContentInstaller.answerForwardedRequest(message.requestId, message.success === true);
+                return;
+            case "graphics-recorded":
+                if (!isLeader)
+                    ContentInstaller.takeGraphicsRecord(message);
+                return;
+            default:
+                if (isLeader)
+                    ContentInstaller.handleFollowerRequest(message);
+        }
+    }
+    static handleFollowerRequest(message) {
+        const groupIds = (message.groupIds != null) ? message.groupIds : null;
+        const requestId = (message.requestId != null) ? message.requestId : null;
+        if (message.type === "install-request")
+            void ContentInstaller.installThenPrepareAsLeader(groupIds, message.background === true, message.prepareGraphics === true, requestId);
+        else if (message.type === "prepare-graphics-request")
+            void ContentInstaller.prepareGraphicsAsLeader(groupIds, message.background === true, message.force === true, requestId);
+        else if (message.type === "remove-request")
+            void ContentInstaller.removeAsLeader(groupIds).then(() => { ContentInstaller.answerRequest(requestId, true); });
+        else if (message.type === "pause")
+            ContentInstaller.Pause();
+        else if (message.type === "resume")
+            ContentInstaller.Resume();
+        else if (message.type === "cancel")
+            ContentInstaller.Cancel();
+    }
+    static mirrorLeaderState(leaderState) {
+        const own = ContentInstaller.state;
+        const contentChangedOnServer = own.contentChangedOnServer || leaderState.contentChangedOnServer === true;
+        ContentInstaller.setState({ ...leaderState, availability: own.availability, reason: own.reason, isLeader: false, persisted: own.persisted, contentChangedOnServer: contentChangedOnServer });
+    }
+    static forwardToLeader(kind, groupIds, background, prepareGraphics, force) {
+        const requestId = Math.random().toString(36).slice(2) + "-" + ContentInstaller.tabStartTime;
+        return new Promise((resolve) => {
+            ContentInstaller.forwardedRequests.set(requestId, { kind: kind, groupIds: groupIds, background: background, prepareGraphics: prepareGraphics, force: force, resolve: resolve });
+            ContentInstaller.postToChannel({ type: kind, requestId: requestId, groupIds: groupIds, background: background, prepareGraphics: prepareGraphics, force: force });
+        });
+    }
+    static answerForwardedRequest(requestId, success) {
+        if (requestId == null)
+            return;
+        const request = ContentInstaller.forwardedRequests.get(requestId);
+        if (request == null)
+            return;
+        ContentInstaller.forwardedRequests.delete(requestId);
+        ContentInstaller.updateTotalsState();
+        request.resolve(success);
+    }
+    static postToChannel(message) {
+        if (ContentInstaller.channel == null)
+            return;
+        try {
+            ContentInstaller.channel.postMessage(message);
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not post to the other tabs: " + String(error));
+        }
+    }
+    static postToWorker(message) {
+        const controller = (typeof navigator !== "undefined" && navigator.serviceWorker != null) ? navigator.serviceWorker.controller : null;
+        if (controller == null)
+            return;
+        try {
+            controller.postMessage(message);
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not message the content worker: " + String(error));
+        }
+    }
+    static pinRoots() {
+        ContentInstaller.roots.forEach((root) => {
+            if (root.state.activeVersion != null)
+                ContentInstaller.postToWorker({ type: "pin", rootKey: root.state.rootKey, version: root.state.activeVersion });
+        });
+    }
+    static async removeAsLeader(groupIds) {
+        const removed = ContentInstaller.resolveGroups(groupIds, false);
+        if (removed.length === 0)
+            return;
+        const isRemoved = (root, groupId) => removed.some((groupRef) => groupRef.root === root && groupRef.groupId === groupId);
+        const keptRefs = [];
+        ContentInstaller.roots.forEach((root) => {
+            for (const groupId of root.state.installedGroups) {
+                if (!isRemoved(root, groupId))
+                    keptRefs.push({ root: root, groupId: groupId });
+            }
+        });
+        const keptHashes = new Set(ContentInstaller.groupFiles(keptRefs).map((file) => file.entry.hash));
+        const deletedHashes = new Set(ContentInstaller.groupFiles(removed).map((file) => file.entry.hash).filter((hash) => !keptHashes.has(hash)));
+        for (const groupRef of removed) {
+            groupRef.root.state.installedGroups = groupRef.root.state.installedGroups.filter((groupId) => groupId !== groupRef.groupId);
+            groupRef.root.state.requestedGroups = groupRef.root.state.requestedGroups.filter((groupId) => groupId !== groupRef.groupId);
+        }
+        await ContentInstaller.deleteHashes(deletedHashes);
+        await ContentInstaller.persistRoots(true);
+        ContentInstaller.updateTotalsState();
+    }
+    static async deleteHashes(hashes) {
+        ContentInstaller.queue = ContentInstaller.queue.filter((job) => {
+            if (!hashes.has(job.hash))
+                return true;
+            ContentInstaller.failedHashes.add(job.hash);
+            return false;
+        });
+        try {
+            const cache = await caches.open(ContentInstaller.CONTENT_FILES_CACHE);
+            for (const hash of Array.from(hashes)) {
+                await cache.delete(ContentInstaller.fileKey(hash));
+                ContentInstaller.storedHashes.delete(hash);
+            }
+        }
+        catch (error) {
+            console.warn("[ContentInstaller] Could not remove stored files: " + String(error));
+        }
+        ContentInstaller.settleFinishedCalls();
+        ContentInstaller.finishSessionIfDrained();
+    }
+    static absoluteUrl(url) {
+        const baseUrl = (typeof document !== "undefined" && document.baseURI) ? document.baseURI : location.href;
+        return new URL(url, baseUrl).href;
+    }
+    static stripQueryAndHash(url) {
+        const queryIndex = url.indexOf("?");
+        const hashIndex = url.indexOf("#");
+        const cutPoints = [queryIndex, hashIndex].filter((index) => index >= 0);
+        return (cutPoints.length > 0) ? url.substring(0, Math.min(...cutPoints)) : url;
+    }
+    static folderOf(url) {
+        const withoutQuery = ContentInstaller.stripQueryAndHash(url);
+        return withoutQuery.substring(0, withoutQuery.lastIndexOf("/") + 1);
+    }
+    static ensureTrailingSlash(url) {
+        return url.endsWith("/") ? url : url + "/";
+    }
+    static isLocalHost(hostname) {
+        const host = hostname.toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+        if (ContentInstaller.LOCAL_HOST_NAMES.indexOf(host) >= 0)
+            return true;
+        if (host.endsWith(ContentInstaller.LOCAL_DOMAIN_SUFFIX))
+            return true;
+        return ContentInstaller.PRIVATE_IPV4_PATTERN.test(host);
+    }
+    static union(first, second) {
+        const result = first.slice();
+        for (const value of second || []) {
+            if (result.indexOf(value) < 0)
+                result.push(value);
+        }
+        return result;
+    }
+}
+ContentInstaller.OnStateChangedObservable = new Observable();
+ContentInstaller.OnProgressObservable = new Observable();
+ContentInstaller.OnErrorObservable = new Observable();
+ContentInstaller.Clock = () => ((typeof performance !== "undefined") ? performance.now() : Date.now());
+ContentInstaller.CONTENT_FILES_CACHE = "bt-content-files-v1";
+ContentInstaller.CONTENT_STATE_CACHE = "bt-content-state-v1";
+ContentInstaller.STORE_KEY_PREFIX = "/__bt-content__/";
+ContentInstaller.INSTALL_MARKER_PARAMETER = "bt-content-install";
+ContentInstaller.ATTEMPT_PARAMETER = "bt-content-attempt";
+ContentInstaller.BROADCAST_CHANNEL_NAME = "bt-content-installer";
+ContentInstaller.IDLE_CONCURRENCY = 4;
+ContentInstaller.BUSY_CONCURRENCY = 1;
+ContentInstaller.MAX_ATTEMPTS = 3;
+ContentInstaller.RETRY_DELAYS_MS = [1000, 4000, 16000];
+ContentInstaller.PROGRESS_INTERVAL_MS = 250;
+ContentInstaller.SPEED_TIME_CONSTANT_SECONDS = 3;
+ContentInstaller.CONTROLLER_WAIT_MS = 3000;
+ContentInstaller.QUOTA_SAFETY_FACTOR = 1.1;
+ContentInstaller.STORE_CONFIRM_TIMEOUT_MS = 30000;
+ContentInstaller.LOCK_NAME = "bt-content-installer";
+ContentInstaller.WORKER_SCRIPT_NAME = "bt-content-worker.js";
+ContentInstaller.SUPPORTED_MANIFEST_FORMAT = 1;
+ContentInstaller.SCENE_FILE_SUFFIXES = [".gz.gltf", ".gz.glb", ".gltf", ".glb"];
+ContentInstaller.LOCAL_HOST_NAMES = ["localhost", "127.0.0.1", "::1"];
+ContentInstaller.LOCAL_DOMAIN_SUFFIX = ".local";
+ContentInstaller.PRIVATE_IPV4_PATTERN = /^(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})$/;
+ContentInstaller.BYTES_PER_MEGABYTE = 1024 * 1024;
+ContentInstaller.MILLISECONDS_PER_SECOND = 1000;
+ContentInstaller.VERSION_DISPLAY_LENGTH = 12;
+ContentInstaller.options = null;
+ContentInstaller.initializePromise = null;
+ContentInstaller.state = ContentInstaller.createInitialState();
+ContentInstaller.roots = new Map();
+ContentInstaller.storedHashes = new Set();
+ContentInstaller.groupsByHash = new Map();
+ContentInstaller.queue = [];
+ContentInstaller.inFlight = new Map();
+ContentInstaller.retryWaits = new Map();
+ContentInstaller.failedHashes = new Set();
+ContentInstaller.storeWaiters = new Map();
+ContentInstaller.installCalls = [];
+ContentInstaller.progress = null;
+ContentInstaller.busy = false;
+ContentInstaller.workerUpdateWaiting = false;
+ContentInstaller.updateDownload = null;
+ContentInstaller.channel = null;
+ContentInstaller.forwardedRequests = new Map();
+ContentInstaller.reportedErrors = new Set();
+ContentInstaller.mismatchRecheckedRoots = new Map();
+ContentInstaller.registration = null;
+ContentInstaller.tabStartTime = 0;
+ContentInstaller.graphicsPreparer = null;
+ContentInstaller.graphicsUnavailable = false;
+ContentInstaller.graphicsRun = null;
+ContentInstaller.graphicsCancelled = false;
+ContentInstaller.GPU_CACHE_LOST_STORAGE_KEY = "bt-gpu-cache-lost";
+ContentInstaller.GPU_CACHE_LOST_EVENT = "bt-gpu-cache-lost";
+ContentInstaller.listensForGpuCacheReports = false;
+ContentInstaller.cancelCount = 0;
+ContentInstaller.graphicsSession = null;
+ContentInstaller.graphicsWaiters = [];