@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerSentEvents.js

@@ -0,0 +1,67 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import { Events } from './NetworkRequest.js';
+import { ServerSentEventsParser } from './ServerSentEventsProtocol.js';
+/**
+ * Server sent events only arrive via CDP (Explicit Network.eventSourceMessageReceived) when
+ * the page uses "EventSource" in the code.
+ *
+ * If the page manually uses 'fetch' or XHR we have to do the protocol parsing
+ * ourselves.
+ *
+ * `ServerSentEvents` is a small helper class that manages this distinction for a specific
+ * request, stores the event data and sends out "EventSourceMessageAdded" events for a request.
+ */
+export class ServerSentEvents {
+    #request;
+    #parser;
+    // In the case where we parse the events ourselves we use the time of the last 'dataReceived'
+    // event for all the events that come out of the corresponding chunk of data.
+    #lastDataReceivedTime = 0;
+    #eventSourceMessages = [];
+    constructor(request, parseFromStreamedData) {
+        this.#request = request;
+        // Only setup parsing if we don't get the events over CDP directly.
+        if (parseFromStreamedData) {
+            this.#lastDataReceivedTime = request.pseudoWallTime(request.startTime);
+            this.#parser = new ServerSentEventsParser(this.#onParserEvent.bind(this), request.charset() ?? undefined);
+            // Get the streaming content and add the already received bytes if someone else started
+            // the streaming earlier.
+            void this.#request.requestStreamingContent().then(streamingContentData => {
+                if (!TextUtils.StreamingContentData.isError(streamingContentData)) {
+                    void this.#parser?.addBase64Chunk(streamingContentData.content().base64);
+                    streamingContentData.addEventListener("ChunkAdded" /* TextUtils.StreamingContentData.Events.CHUNK_ADDED */, ({ data: { chunk } }) => {
+                        this.#lastDataReceivedTime = request.pseudoWallTime(request.endTime);
+                        void this.#parser?.addBase64Chunk(chunk);
+                    });
+                }
+            });
+        }
+    }
+    get eventSourceMessages() {
+        return this.#eventSourceMessages;
+    }
+    /** Forwarded Network.eventSourceMessage received */
+    onProtocolEventSourceMessageReceived(eventName, data, eventId, time) {
+        this.#recordMessageAndDispatchEvent({
+            eventName,
+            eventId,
+            data,
+            time,
+        });
+    }
+    #onParserEvent(eventName, data, eventId) {
+        this.#recordMessageAndDispatchEvent({
+            eventName,
+            eventId,
+            data,
+            time: this.#lastDataReceivedTime,
+        });
+    }
+    #recordMessageAndDispatchEvent(message) {
+        this.#eventSourceMessages.push(message);
+        this.#request.dispatchEventToListeners(Events.EVENT_SOURCE_MESSAGE_ADDED, message);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerSentEventsProtocol.js

@@ -0,0 +1,113 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * Implements Server-Sent-Events protocl parsing as described by
+ * https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+ *
+ * Webpages can use SSE over fetch/XHR and not go through EventSource. DevTools
+ * only receives the raw binary data in this case, which means we have to decode
+ * and parse the event stream ourselves here.
+ *
+ * Implementation mostly ported over from blink
+ * third_party/blink/renderer/modules/eventsource/event_source_parser.cc.
+ */
+export class ServerSentEventsParser {
+    #onEventCallback;
+    #decoder;
+    // Parser state.
+    #isRecognizingCrLf = false;
+    #line = '';
+    #id = '';
+    #data = '';
+    #eventType = '';
+    constructor(callback, encodingLabel) {
+        this.#onEventCallback = callback;
+        this.#decoder = new Base64TextDecoder(this.#onTextChunk.bind(this), encodingLabel);
+    }
+    async addBase64Chunk(raw) {
+        await this.#decoder.addBase64Chunk(raw);
+    }
+    addTextChunk(chunk) {
+        this.#onTextChunk(chunk);
+    }
+    #onTextChunk(chunk) {
+        // A line consists of "this.#line" plus a slice of "chunk[start:<next new cr/lf>]".
+        let start = 0;
+        for (let i = 0; i < chunk.length; ++i) {
+            if (this.#isRecognizingCrLf && chunk[i] === '\n') {
+                // We found the latter part of "\r\n".
+                this.#isRecognizingCrLf = false;
+                ++start;
+                continue;
+            }
+            this.#isRecognizingCrLf = false;
+            if (chunk[i] === '\r' || chunk[i] === '\n') {
+                this.#line += chunk.substring(start, i);
+                this.#parseLine();
+                this.#line = '';
+                start = i + 1;
+                this.#isRecognizingCrLf = chunk[i] === '\r';
+            }
+        }
+        this.#line += chunk.substring(start);
+    }
+    #parseLine() {
+        if (this.#line.length === 0) {
+            // We dispatch an event when seeing an empty line.
+            if (this.#data.length > 0) {
+                const data = this.#data.slice(0, -1); // Remove the last newline.
+                this.#onEventCallback(this.#eventType || 'message', data, this.#id);
+                this.#data = '';
+            }
+            this.#eventType = '';
+            return;
+        }
+        let fieldNameEnd = this.#line.indexOf(':');
+        let fieldValueStart;
+        if (fieldNameEnd < 0) {
+            fieldNameEnd = this.#line.length;
+            fieldValueStart = fieldNameEnd;
+        }
+        else {
+            fieldValueStart = fieldNameEnd + 1;
+            if (fieldValueStart < this.#line.length && this.#line[fieldValueStart] === ' ') {
+                // Skip a single space preceeding the value.
+                ++fieldValueStart;
+            }
+        }
+        const fieldName = this.#line.substring(0, fieldNameEnd);
+        if (fieldName === 'event') {
+            this.#eventType = this.#line.substring(fieldValueStart);
+            return;
+        }
+        if (fieldName === 'data') {
+            this.#data += this.#line.substring(fieldValueStart);
+            this.#data += '\n';
+        }
+        if (fieldName === 'id') {
+            // We should do a check here whether the id field contains "\0" and ignore it.
+            this.#id = this.#line.substring(fieldValueStart);
+        }
+        // Ignore all other fields. Also ignore "retry", we won't forward that to the backend.
+    }
+}
+/**
+ * Small helper class that can decode a stream of base64 encoded bytes. Specify the
+ * text encoding for the raw bytes via constructor. Default is utf-8.
+ */
+class Base64TextDecoder {
+    #decoder;
+    #writer;
+    constructor(onTextChunk, encodingLabel) {
+        this.#decoder = new TextDecoderStream(encodingLabel);
+        this.#writer = this.#decoder.writable.getWriter();
+        void this.#decoder.readable.pipeTo(new WritableStream({ write: onTextChunk }));
+    }
+    async addBase64Chunk(chunk) {
+        const binString = window.atob(chunk);
+        const bytes = Uint8Array.from(binString, m => m.codePointAt(0));
+        await this.#writer.ready;
+        await this.#writer.write(bytes);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerTiming.js

@@ -0,0 +1,216 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../common/common.js';
+import * as i18n from '../i18n/i18n.js';
+const UIStrings = {
+    /**
+     * @description Text in Server Timing
+     * @example {sql-lookup} PH1
+     */
+    deprecatedSyntaxFoundPleaseUse: 'Deprecated syntax found for metric "{PH1}". Please use: <name>;dur=<duration>;desc=<description>',
+    /**
+     * @description Text in Server Timing
+     * @example {https} PH1
+     */
+    duplicateParameterSIgnored: 'Duplicate parameter "{PH1}" ignored.',
+    /**
+     * @description Text in Server Timing
+     * @example {https} PH1
+     */
+    noValueFoundForParameterS: 'No value found for parameter "{PH1}".',
+    /**
+     * @description Text in Server Timing
+     * @example {https} PH1
+     */
+    unrecognizedParameterS: 'Unrecognized parameter "{PH1}".',
+    /**
+     * @description Text in Server Timing
+     */
+    extraneousTrailingCharacters: 'Extraneous trailing characters.',
+    /**
+     * @description Text in Server Timing
+     * @example {https} PH1
+     * @example {2.0} PH2
+     */
+    unableToParseSValueS: 'Unable to parse "{PH1}" value "{PH2}".',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/ServerTiming.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export const cloudflarePrefix = '(cf) ';
+export const cloudinaryPrefix = '(cld) ';
+export class ServerTiming {
+    metric;
+    value;
+    description;
+    constructor(metric, value, description) {
+        this.metric = metric;
+        this.value = value;
+        this.description = description;
+    }
+    static parseHeaders(headers) {
+        const rawServerTimingHeaders = headers.filter(item => item.name.toLowerCase() === 'server-timing');
+        if (!rawServerTimingHeaders.length) {
+            return null;
+        }
+        const serverTimings = rawServerTimingHeaders.reduce((timings, header) => {
+            const timing = this.createFromHeaderValue(header.value);
+            timings.push(...timing.map(function (entry) {
+                return new ServerTiming(entry.name, entry.dur ?? null, entry.desc ?? '');
+            }));
+            return timings;
+        }, []);
+        return serverTimings;
+    }
+    static createFromHeaderValue(valueString) {
+        function trimLeadingWhiteSpace() {
+            valueString = valueString.replace(/^\s*/, '');
+        }
+        function consumeDelimiter(char) {
+            console.assert(char.length === 1);
+            trimLeadingWhiteSpace();
+            if (valueString.charAt(0) !== char) {
+                return false;
+            }
+            valueString = valueString.substring(1);
+            return true;
+        }
+        function consumeToken() {
+            // https://tools.ietf.org/html/rfc7230#appendix-B
+            const result = /^(?:\s*)([\w!#$%&'*+\-.^`|~]+)(?:\s*)(.*)/.exec(valueString);
+            if (!result) {
+                return null;
+            }
+            valueString = result[2];
+            return result[1];
+        }
+        function consumeTokenOrQuotedString() {
+            trimLeadingWhiteSpace();
+            if (valueString.charAt(0) === '"') {
+                return consumeQuotedString();
+            }
+            return consumeToken();
+        }
+        function consumeQuotedString() {
+            console.assert(valueString.charAt(0) === '"');
+            valueString = valueString.substring(1); // remove leading DQUOTE
+            let value = '';
+            while (valueString.length) {
+                // split into two parts:
+                //  -everything before the first " or \
+                //  -everything else
+                const result = /^([^"\\]*)(.*)/.exec(valueString);
+                if (!result) {
+                    return null; // not a valid quoted-string
+                }
+                value += result[1];
+                if (result[2].charAt(0) === '"') {
+                    // we have found our closing "
+                    valueString = result[2].substring(1); // strip off everything after the closing "
+                    return value; // we are done here
+                }
+                console.assert(result[2].charAt(0) === '\\');
+                // special rules for \ found in quoted-string (https://tools.ietf.org/html/rfc7230#section-3.2.6)
+                value += result[2].charAt(1); // grab the character AFTER the \ (if there was one)
+                valueString = result[2].substring(2); // strip off \ and next character
+            }
+            return null; // not a valid quoted-string
+        }
+        function consumeExtraneous() {
+            const result = /([,;].*)/.exec(valueString);
+            if (result) {
+                valueString = result[1];
+            }
+        }
+        const result = [];
+        let name;
+        while ((name = consumeToken()) !== null) {
+            const entry = { name };
+            if (valueString.charAt(0) === '=') {
+                this.showWarning(i18nString(UIStrings.deprecatedSyntaxFoundPleaseUse, { PH1: name }));
+            }
+            while (consumeDelimiter(';')) {
+                let paramName;
+                if ((paramName = consumeToken()) === null) {
+                    continue;
+                }
+                paramName = paramName.toLowerCase();
+                const parseParameter = this.getParserForParameter(paramName);
+                let paramValue = null;
+                if (consumeDelimiter('=')) {
+                    // always parse the value, even if we don't recognize the parameter #name
+                    paramValue = consumeTokenOrQuotedString();
+                    consumeExtraneous();
+                }
+                if (parseParameter) {
+                    // paramName is valid
+                    if (entry.hasOwnProperty(paramName)) {
+                        this.showWarning(i18nString(UIStrings.duplicateParameterSIgnored, { PH1: paramName }));
+                        continue;
+                    }
+                    if (paramValue === null) {
+                        this.showWarning(i18nString(UIStrings.noValueFoundForParameterS, { PH1: paramName }));
+                    }
+                    parseParameter.call(this, entry, paramValue);
+                }
+                else {
+                    // paramName is not valid
+                    // TODO(paulirish): consider showing other included params, like `start`: https://github.com/w3c/server-timing/issues/43
+                    this.showWarning(i18nString(UIStrings.unrecognizedParameterS, { PH1: paramName }));
+                }
+            }
+            result.push(entry);
+            // Special parsing for cloudflare's bespoke format. https://blog.cloudflare.com/new-standards/#measuring-impact
+            // We extract the individual items of the cfL4 server-timing for clear presentation
+            if (entry.name === 'cfL4' && entry.desc) {
+                new URLSearchParams(entry.desc).entries().forEach(([key, val]) => {
+                    result.push({ name: `${cloudflarePrefix}${key}`, desc: val });
+                });
+            }
+            // Special parsing for cloudinary's bespoke format. https://cloudinary.com/blog/inside_the_black_box_with_server_timing#what_details_are_you_sharing_
+            // The format has changed since this blog post
+            if (entry.name === 'content-info' && entry.desc) {
+                new URLSearchParams(entry.desc.replace(/,/g, '&')).entries().forEach(([key, val]) => {
+                    result.push({ name: `${cloudinaryPrefix}${key}`, desc: val });
+                });
+            }
+            if (!consumeDelimiter(',')) {
+                break;
+            }
+        }
+        if (valueString.length) {
+            this.showWarning(i18nString(UIStrings.extraneousTrailingCharacters));
+        }
+        return result;
+    }
+    static getParserForParameter(paramName) {
+        switch (paramName) {
+            case 'dur': {
+                function durParser(entry, paramValue) {
+                    entry.dur = 0;
+                    if (paramValue !== null) {
+                        const duration = parseFloat(paramValue);
+                        if (isNaN(duration)) {
+                            ServerTiming.showWarning(i18nString(UIStrings.unableToParseSValueS, { PH1: paramName, PH2: paramValue }));
+                            return;
+                        }
+                        entry.dur = duration;
+                    }
+                }
+                return durParser;
+            }
+            case 'desc': {
+                function descParser(entry, paramValue) {
+                    entry.desc = paramValue || '';
+                }
+                return descParser;
+            }
+            default: {
+                return null;
+            }
+        }
+    }
+    static showWarning(msg) {
+        Common.Console.Console.instance().warn(`ServerTiming: ${msg}`);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServiceWorkerCacheModel.js

@@ -0,0 +1,271 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../common/common.js';
+import * as i18n from '../i18n/i18n.js';
+import { SDKModel } from './SDKModel.js';
+import { StorageBucketsModel } from './StorageBucketsModel.js';
+const UIStrings = {
+    /**
+     * @description Text in Service Worker Cache Model
+     * @example {https://cache} PH1
+     * @example {error message} PH2
+     */
+    serviceworkercacheagentError: '`ServiceWorkerCacheAgent` error deleting cache entry {PH1} in cache: {PH2}',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/ServiceWorkerCacheModel.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class ServiceWorkerCacheModel extends SDKModel {
+    cacheAgent;
+    #storageAgent;
+    #storageBucketModel;
+    #caches = new Map();
+    #storageKeysTracked = new Set();
+    #storageBucketsUpdated = new Set();
+    #throttler = new Common.Throttler.Throttler(2000);
+    #enabled = false;
+    // Used by tests to remove the Throttler timeout.
+    #scheduleAsSoonAsPossible = false;
+    /**
+     * Invariant: This #model can only be constructed on a ServiceWorker target.
+     */
+    constructor(target) {
+        super(target);
+        target.registerStorageDispatcher(this);
+        this.cacheAgent = target.cacheStorageAgent();
+        this.#storageAgent = target.storageAgent();
+        this.#storageBucketModel = target.model(StorageBucketsModel);
+    }
+    enable() {
+        if (this.#enabled) {
+            return;
+        }
+        this.#storageBucketModel.addEventListener("BucketAdded" /* StorageBucketsModelEvents.BUCKET_ADDED */, this.storageBucketAdded, this);
+        this.#storageBucketModel.addEventListener("BucketRemoved" /* StorageBucketsModelEvents.BUCKET_REMOVED */, this.storageBucketRemoved, this);
+        for (const storageBucket of this.#storageBucketModel.getBuckets()) {
+            this.addStorageBucket(storageBucket.bucket);
+        }
+        this.#enabled = true;
+    }
+    clearForStorageKey(storageKey) {
+        for (const [opaqueId, cache] of this.#caches.entries()) {
+            if (cache.storageKey === storageKey) {
+                this.#caches.delete((opaqueId));
+                this.cacheRemoved((cache));
+            }
+        }
+        for (const storageBucket of this.#storageBucketModel.getBucketsForStorageKey(storageKey)) {
+            void this.loadCacheNames(storageBucket.bucket);
+        }
+    }
+    refreshCacheNames() {
+        for (const cache of this.#caches.values()) {
+            this.cacheRemoved(cache);
+        }
+        this.#caches.clear();
+        const storageBuckets = this.#storageBucketModel.getBuckets();
+        for (const storageBucket of storageBuckets) {
+            void this.loadCacheNames(storageBucket.bucket);
+        }
+    }
+    async deleteCache(cache) {
+        const response = await this.cacheAgent.invoke_deleteCache({ cacheId: cache.cacheId });
+        if (response.getError()) {
+            console.error(`ServiceWorkerCacheAgent error deleting cache ${cache.toString()}: ${response.getError()}`);
+            return;
+        }
+        this.#caches.delete(cache.cacheId);
+        this.cacheRemoved(cache);
+    }
+    async deleteCacheEntry(cache, request) {
+        const response = await this.cacheAgent.invoke_deleteEntry({ cacheId: cache.cacheId, request });
+        if (response.getError()) {
+            Common.Console.Console.instance().error(i18nString(UIStrings.serviceworkercacheagentError, { PH1: cache.toString(), PH2: String(response.getError()) }));
+            return;
+        }
+    }
+    loadCacheData(cache, skipCount, pageSize, pathFilter, callback) {
+        void this.requestEntries(cache, skipCount, pageSize, pathFilter, callback);
+    }
+    loadAllCacheData(cache, pathFilter, callback) {
+        void this.requestAllEntries(cache, pathFilter, callback);
+    }
+    caches() {
+        return [...this.#caches.values()];
+    }
+    dispose() {
+        for (const cache of this.#caches.values()) {
+            this.cacheRemoved(cache);
+        }
+        this.#caches.clear();
+        if (this.#enabled) {
+            this.#storageBucketModel.removeEventListener("BucketAdded" /* StorageBucketsModelEvents.BUCKET_ADDED */, this.storageBucketAdded, this);
+            this.#storageBucketModel.removeEventListener("BucketRemoved" /* StorageBucketsModelEvents.BUCKET_REMOVED */, this.storageBucketRemoved, this);
+        }
+    }
+    addStorageBucket(storageBucket) {
+        void this.loadCacheNames(storageBucket);
+        if (!this.#storageKeysTracked.has(storageBucket.storageKey)) {
+            this.#storageKeysTracked.add(storageBucket.storageKey);
+            void this.#storageAgent.invoke_trackCacheStorageForStorageKey({ storageKey: storageBucket.storageKey });
+        }
+    }
+    removeStorageBucket(storageBucket) {
+        let storageKeyCount = 0;
+        for (const [opaqueId, cache] of this.#caches.entries()) {
+            if (storageBucket.storageKey === cache.storageKey) {
+                storageKeyCount++;
+            }
+            if (cache.inBucket(storageBucket)) {
+                storageKeyCount--;
+                this.#caches.delete((opaqueId));
+                this.cacheRemoved((cache));
+            }
+        }
+        if (storageKeyCount === 0) {
+            this.#storageKeysTracked.delete(storageBucket.storageKey);
+            void this.#storageAgent.invoke_untrackCacheStorageForStorageKey({ storageKey: storageBucket.storageKey });
+        }
+    }
+    async loadCacheNames(storageBucket) {
+        const response = await this.cacheAgent.invoke_requestCacheNames({ storageBucket });
+        if (response.getError()) {
+            return;
+        }
+        this.updateCacheNames(storageBucket, response.caches);
+    }
+    updateCacheNames(storageBucket, cachesJson) {
+        function deleteAndSaveOldCaches(cache) {
+            if (cache.inBucket(storageBucket) && !updatingCachesIds.has(cache.cacheId)) {
+                oldCaches.set(cache.cacheId, cache);
+                this.#caches.delete(cache.cacheId);
+            }
+        }
+        const updatingCachesIds = new Set();
+        const newCaches = new Map();
+        const oldCaches = new Map();
+        for (const cacheJson of cachesJson) {
+            const storageBucket = cacheJson.storageBucket ??
+                this.#storageBucketModel.getDefaultBucketForStorageKey(cacheJson.storageKey)?.bucket;
+            if (!storageBucket) {
+                continue;
+            }
+            const cache = new Cache(this, storageBucket, cacheJson.cacheName, cacheJson.cacheId);
+            updatingCachesIds.add(cache.cacheId);
+            if (this.#caches.has(cache.cacheId)) {
+                continue;
+            }
+            newCaches.set(cache.cacheId, cache);
+            this.#caches.set(cache.cacheId, cache);
+        }
+        this.#caches.forEach(deleteAndSaveOldCaches, this);
+        newCaches.forEach(this.cacheAdded, this);
+        oldCaches.forEach(this.cacheRemoved, this);
+    }
+    storageBucketAdded({ data: { bucketInfo: { bucket } } }) {
+        this.addStorageBucket(bucket);
+    }
+    storageBucketRemoved({ data: { bucketInfo: { bucket } } }) {
+        this.removeStorageBucket(bucket);
+    }
+    cacheAdded(cache) {
+        this.dispatchEventToListeners("CacheAdded" /* Events.CACHE_ADDED */, { model: this, cache });
+    }
+    cacheRemoved(cache) {
+        this.dispatchEventToListeners("CacheRemoved" /* Events.CACHE_REMOVED */, { model: this, cache });
+    }
+    async requestEntries(cache, skipCount, pageSize, pathFilter, callback) {
+        const response = await this.cacheAgent.invoke_requestEntries({ cacheId: cache.cacheId, skipCount, pageSize, pathFilter });
+        if (response.getError()) {
+            console.error('ServiceWorkerCacheAgent error while requesting entries: ', response.getError());
+            return;
+        }
+        callback(response.cacheDataEntries, response.returnCount);
+    }
+    async requestAllEntries(cache, pathFilter, callback) {
+        const response = await this.cacheAgent.invoke_requestEntries({ cacheId: cache.cacheId, pathFilter });
+        if (response.getError()) {
+            console.error('ServiceWorkerCacheAgent error while requesting entries: ', response.getError());
+            return;
+        }
+        callback(response.cacheDataEntries, response.returnCount);
+    }
+    cacheStorageListUpdated({ bucketId }) {
+        const storageBucket = this.#storageBucketModel.getBucketById(bucketId)?.bucket;
+        if (storageBucket) {
+            this.#storageBucketsUpdated.add(storageBucket);
+            void this.#throttler.schedule(() => {
+                const promises = Array.from(this.#storageBucketsUpdated, storageBucket => this.loadCacheNames(storageBucket));
+                this.#storageBucketsUpdated.clear();
+                return Promise.all(promises);
+            }, this.#scheduleAsSoonAsPossible ? "AsSoonAsPossible" /* Common.Throttler.Scheduling.AS_SOON_AS_POSSIBLE */ :
+                "Default" /* Common.Throttler.Scheduling.DEFAULT */);
+        }
+    }
+    cacheStorageContentUpdated({ bucketId, cacheName }) {
+        const storageBucket = this.#storageBucketModel.getBucketById(bucketId)?.bucket;
+        if (storageBucket) {
+            this.dispatchEventToListeners("CacheStorageContentUpdated" /* Events.CACHE_STORAGE_CONTENT_UPDATED */, { storageBucket, cacheName });
+        }
+    }
+    attributionReportingTriggerRegistered(_event) {
+    }
+    indexedDBListUpdated(_event) {
+    }
+    indexedDBContentUpdated(_event) {
+    }
+    interestGroupAuctionEventOccurred(_event) {
+    }
+    interestGroupAccessed(_event) {
+    }
+    interestGroupAuctionNetworkRequestCreated(_event) {
+    }
+    sharedStorageAccessed(_event) {
+    }
+    sharedStorageWorkletOperationExecutionFinished(_event) {
+    }
+    storageBucketCreatedOrUpdated(_event) {
+    }
+    storageBucketDeleted(_event) {
+    }
+    setThrottlerSchedulesAsSoonAsPossibleForTest() {
+        this.#scheduleAsSoonAsPossible = true;
+    }
+    attributionReportingSourceRegistered(_event) {
+    }
+    attributionReportingReportSent(_event) {
+    }
+    attributionReportingVerboseDebugReportSent(_event) {
+    }
+}
+export class Cache {
+    #model;
+    storageKey;
+    storageBucket;
+    cacheName;
+    cacheId;
+    constructor(model, storageBucket, cacheName, cacheId) {
+        this.#model = model;
+        this.storageBucket = storageBucket;
+        this.storageKey = storageBucket.storageKey;
+        this.cacheName = cacheName;
+        this.cacheId = cacheId;
+    }
+    inBucket(storageBucket) {
+        return this.storageKey === storageBucket.storageKey && this.storageBucket.name === storageBucket.name;
+    }
+    equals(cache) {
+        return this.cacheId === cache.cacheId;
+    }
+    toString() {
+        return this.storageKey + this.cacheName;
+    }
+    async requestCachedResponse(url, requestHeaders) {
+        const response = await this.#model.cacheAgent.invoke_requestCachedResponse({ cacheId: this.cacheId, requestURL: url, requestHeaders });
+        if (response.getError()) {
+            return null;
+        }
+        return response.response;
+    }
+}
+SDKModel.register(ServiceWorkerCacheModel, { capabilities: 8192 /* Capability.STORAGE */, autostart: false });