opera-devtools-mcp 0.6.0 → 0.7.0

package/build/src/index.js

@@ -5,21 +5,22 @@
  *
  * Modified by Opera Software AS.
  */
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
 import { loadIssueDescriptions } from './devtools/issueDescriptions.js';
 import { McpContext } from './McpContext.js';
 import { BROWSER_EXPOSURE_DISCLAIMER, showUsageStatisticsDisclaimer, } from './opera/policy.js';
-import { createOperaToolHooks } from './opera/toolHandlerHooks.js';
 import { buildLaunchOptions } from './opera/browserLaunch.js';
+import { createOperaToolHooks, } from './opera/toolHandlerHooks.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
 import { FilePersistence } from './telemetry/persistence.js';
-import { McpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, } from './third_party/index.js';
+import { McpServer as SdkMcpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, Mutex, puppeteer, } from './third_party/index.js';
 import { ToolHandler } from './ToolHandler.js';
 import { createTools } from './tools/tools.js';
 import { logger } from './utils/logger.js';
-import { Mutex } from './third_party/index.js';
 import { VERSION } from './version.js';
-export { buildFlag } from './ToolHandler.js';
+puppeteer.setFollowSymlinks(false);
 /**
  * Timeout for a `roots/list` that a tool call is waiting on, matching the 5s
  * default used for page operations. `getContext()` awaits it while
@@ -29,84 +30,151 @@ export { buildFlag } from './ToolHandler.js';
  * slow client sends late still land.
  */
 const ROOTS_REQUEST_TIMEOUT = 5_000;
-export async function createMcpServer(serverArgs, options) {
-    // Opera forces `usageStatistics` off in ./opera/policy.ts, so this stays
-    // dormant. Kept identical to upstream so the seam is the policy, not this file.
-    if (serverArgs.usageStatistics) {
-        ClearcutLogger.initialize({
-            persistence: new FilePersistence(),
-            logFile: serverArgs.logFile,
-            appVersion: VERSION,
-            clearcutEndpoint: serverArgs.clearcutEndpoint,
-            clearcutForceFlushIntervalMs: serverArgs.clearcutForceFlushIntervalMs,
-            clearcutIncludePidHeader: serverArgs.clearcutIncludePidHeader,
+export class McpServer {
+    server;
+    #serverArgs;
+    #options;
+    #context;
+    /**
+     * Client roots stay valid across browser reconnects and only the client can
+     * invalidate them through a `roots/list_changed` notification. CLI-configured
+     * roots are read from `#serverArgs` when combining roots.
+     */
+    #lastClientRoots;
+    #toolMutex = new Mutex();
+    #operaHooks;
+    constructor(serverArgs, options = {}) {
+        this.#serverArgs = serverArgs;
+        this.#options = options;
+        this.#operaHooks = createOperaToolHooks({
+            serverArgs: this.#serverArgs,
+            logFile: this.#options.logFile,
+            resetContext: () => {
+                this.#context?.dispose();
+                this.#context = undefined;
+            },
         });
+        if (this.#serverArgs.usageStatistics) {
+            ClearcutLogger.initialize({
+                persistence: new FilePersistence(),
+                logFile: this.#serverArgs.logFile,
+                appVersion: VERSION,
+                clearcutEndpoint: this.#serverArgs.clearcutEndpoint,
+                clearcutForceFlushIntervalMs: this.#serverArgs.clearcutForceFlushIntervalMs,
+                clearcutIncludePidHeader: this.#serverArgs.clearcutIncludePidHeader,
+            });
+        }
+        this.server = new SdkMcpServer({
+            name: 'chrome_devtools',
+            title: 'Chrome DevTools MCP server',
+            version: VERSION,
+        }, { capabilities: { logging: {} } });
+        this.server.server.setRequestHandler(SetLevelRequestSchema, () => {
+            return {};
+        });
+        this.server.server.oninitialized = () => {
+            const clientName = this.server.server.getClientVersion()?.name;
+            if (clientName) {
+                ClearcutLogger.get()?.setClientName(clientName);
+            }
+            if (this.server.server.getClientCapabilities()?.roots) {
+                void this.#updateRoots();
+                this.server.server.setNotificationHandler(RootsListChangedNotificationSchema, () => {
+                    void this.#updateRoots();
+                });
+            }
+            else if (!this.#serverArgs.allowUnrestrictedPaths &&
+                (this.#serverArgs.filesystemRoot ?? []).length === 0) {
+                console.warn('[chrome-devtools-mcp] The connecting client did not negotiate the MCP roots ' +
+                    'capability. File-writing tools will be restricted to the OS temp directory. ' +
+                    'To restore the previous unrestricted behavior, start the server with ' +
+                    '--allow-unrestricted-paths.');
+            }
+        };
+    }
+    async connect(transport) {
+        return await this.server.connect(transport);
+    }
+    /**
+     * Closes the MCP connection and disposes internal context/listeners.
+     */
+    async close() {
+        this.#context?.dispose();
+        this.#context = undefined;
+        await this.server.close();
+    }
+    [Symbol.dispose]() {
+        this.close().catch(() => {
+            // TODO: wire up the logger
+        });
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    static async from(serverArgs, options = {}) {
+        const server = new McpServer(serverArgs, options);
+        await server.#init();
+        return server;
+    }
+    async #init() {
+        const tools = createTools(this.#serverArgs);
+        for (const tool of tools) {
+            this.#registerTool(tool);
+        }
+        await loadIssueDescriptions();
     }
-    const server = new McpServer({
-        name: 'chrome_devtools',
-        title: 'Chrome DevTools MCP server',
-        version: VERSION,
-    }, { capabilities: { logging: {} } });
-    server.server.setRequestHandler(SetLevelRequestSchema, () => {
-        return {};
-    });
-    // Roots are client state rather than browser state, so the last listing stays
-    // valid across browser reconnects and only the client can invalidate it, via
-    // the `roots/list_changed` notification handled below
-    let lastRoots;
-    // `timeout` is only passed where a tool call is waiting on the result – the
-    // background refreshes below block nobody, so bounding them would just discard
-    // roots a slow client was about to send
-    const updateRoots = async (timeout) => {
-        if (!server.server.getClientCapabilities()?.roots) {
+    #combinedRoots() {
+        const configuredRoots = (this.#serverArgs.allowUnrestrictedPaths
+            ? []
+            : (this.#serverArgs.filesystemRoot ?? [])).map(root => {
+            const rootPath = path.resolve(String(root));
+            return {
+                uri: pathToFileURL(rootPath).href,
+                name: path.basename(rootPath) || rootPath,
+            };
+        });
+        if (configuredRoots.length === 0 && this.#lastClientRoots === undefined) {
+            return undefined;
+        }
+        return [...configuredRoots, ...(this.#lastClientRoots ?? [])];
+    }
+    /**
+     * `timeout` is only passed where a tool call is waiting on the result – the
+     * background refreshes below block nobody, so bounding them would just discard
+     * roots a slow client was about to send
+     */
+    async #updateRoots(timeout) {
+        if (!this.server.server.getClientCapabilities()?.roots) {
             return;
         }
         try {
-            const roots = await server.server.request({ method: 'roots/list' }, ListRootsResultSchema, timeout === undefined ? undefined : { timeout });
-            lastRoots = roots.roots;
-            context?.setRoots(lastRoots);
+            const roots = await this.server.server.request({ method: 'roots/list' }, ListRootsResultSchema, timeout === undefined ? undefined : { timeout });
+            this.#lastClientRoots = roots.roots;
+            this.#context?.setRoots(this.#combinedRoots());
         }
         catch (e) {
             logger?.('Failed to list roots', e);
         }
-    };
-    server.server.oninitialized = () => {
-        const clientName = server.server.getClientVersion()?.name;
-        if (clientName) {
-            ClearcutLogger.get()?.setClientName(clientName);
-        }
-        if (server.server.getClientCapabilities()?.roots) {
-            void updateRoots();
-            server.server.setNotificationHandler(RootsListChangedNotificationSchema, () => {
-                void updateRoots();
-            });
-        }
-        else if (!serverArgs.allowUnrestrictedPaths) {
-            console.warn('[chrome-devtools-mcp] The connecting client did not negotiate the MCP roots ' +
-                'capability. File-writing tools will be restricted to the OS temp directory. ' +
-                'To restore the previous unrestricted behavior, start the server with ' +
-                '--allow-unrestricted-paths.');
-        }
-    };
-    let context;
-    async function getContext() {
-        const devtools = serverArgs.experimentalDevtools ?? false;
-        const blocklist = serverArgs.blockedUrlPattern
-            ? serverArgs.blockedUrlPattern.map(String)
+    }
+    async #getContext() {
+        const devtools = this.#serverArgs.experimentalDevtools ?? false;
+        const blocklist = this.#serverArgs.blockedUrlPattern
+            ? this.#serverArgs.blockedUrlPattern.map(String)
             : undefined;
-        const allowlist = serverArgs.allowedUrlPattern
-            ? serverArgs.allowedUrlPattern.map(String)
+        const allowlist = this.#serverArgs.allowedUrlPattern
+            ? this.#serverArgs.allowedUrlPattern.map(String)
             : undefined;
-        const browser = serverArgs.browserUrl || serverArgs.wsEndpoint || serverArgs.autoConnect
+        const channel = this.#serverArgs.channel;
+        const browser = this.#serverArgs.browserUrl ||
+            this.#serverArgs.wsEndpoint ||
+            this.#serverArgs.autoConnect
             ? await ensureBrowserConnected({
-                browserURL: serverArgs.browserUrl,
-                wsEndpoint: serverArgs.wsEndpoint,
-                wsHeaders: serverArgs.wsHeaders,
+                browserURL: this.#serverArgs.browserUrl,
+                wsEndpoint: this.#serverArgs.wsEndpoint,
+                wsHeaders: this.#serverArgs.wsHeaders,
                 // Important: only pass channel, if autoConnect is true.
-                channel: serverArgs.autoConnect
-                    ? serverArgs.channel
-                    : undefined,
-                userDataDir: serverArgs.userDataDir,
+                channel: this.#serverArgs.autoConnect ? channel : undefined,
+                userDataDir: this.#serverArgs.userDataDir,
                 devtools,
                 blocklist,
                 allowlist,
@@ -114,52 +182,45 @@ export async function createMcpServer(serverArgs, options) {
             : await ensureBrowserLaunched(
             // Pass the already-derived values so the launched browser uses the
             // exact same flags as the connected branch and `McpContext`.
-            buildLaunchOptions(serverArgs, options.logFile, {
+            buildLaunchOptions(this.#serverArgs, this.#options.logFile, {
                 devtools,
                 blocklist,
                 allowlist,
             }));
-        if (context?.browser !== browser) {
-            context?.dispose();
-            context = await McpContext.from(browser, logger, {
+        if (this.#context?.browser !== browser) {
+            this.#context?.dispose();
+            this.#context = await McpContext.from(browser, logger, {
                 experimentalDevToolsDebugging: devtools,
-                experimentalIncludeAllPages: serverArgs.experimentalIncludeAllPages,
-                performanceCrux: serverArgs.performanceCrux,
+                experimentalIncludeAllPages: this.#serverArgs.experimentalIncludeAllPages,
+                performanceCrux: this.#serverArgs.performanceCrux,
+                sourceMaps: this.#serverArgs.sourceMaps,
                 allowList: allowlist,
                 blocklist: blocklist,
-                allowUnrestrictedPaths: serverArgs.allowUnrestrictedPaths,
+                allowUnrestrictedPaths: this.#serverArgs.allowUnrestrictedPaths,
                 // Surfaces a one-time note in the next response after a reconnect.
-                reconnected: context !== undefined,
+                reconnected: this.#context !== undefined,
+                categoryExtensions: this.#serverArgs.categoryExtensions,
             });
-            if (lastRoots === undefined) {
+            this.#context.setRoots(this.#combinedRoots());
+            if (this.#lastClientRoots === undefined) {
                 // Nothing listed yet, so this call has to wait – bounded, since it is
                 // holding the tool mutex, and a later background refresh still lands
-                await updateRoots(ROOTS_REQUEST_TIMEOUT);
+                await this.#updateRoots(ROOTS_REQUEST_TIMEOUT);
             }
             else {
                 // Carry the known roots over and refresh out of band, so a reconnect
                 // never pays for a client round-trip
-                context.setRoots(lastRoots);
-                void updateRoots();
+                void this.#updateRoots();
             }
         }
-        return context;
+        return this.#context;
     }
-    const operaHooks = createOperaToolHooks({
-        serverArgs,
-        logFile: options.logFile,
-        resetContext: () => {
-            context?.dispose();
-            context = undefined;
-        },
-    });
-    const toolMutex = new Mutex();
-    function registerTool(tool) {
-        const toolHandler = new ToolHandler(tool, serverArgs, getContext, toolMutex, operaHooks);
+    #registerTool(tool) {
+        const toolHandler = new ToolHandler(tool, this.#serverArgs, () => this.#getContext(), this.#toolMutex, this.#operaHooks);
         if (!toolHandler.shouldRegister) {
             return;
         }
-        server.registerTool(tool.name, {
+        this.server.registerTool(tool.name, {
             description: tool.description,
             inputSchema: toolHandler.registeredInputSchema,
             annotations: tool.annotations,
@@ -167,12 +228,17 @@ export async function createMcpServer(serverArgs, options) {
             return await toolHandler.handle(params, extra);
         });
     }
-    const tools = createTools(serverArgs);
-    for (const tool of tools) {
-        registerTool(tool);
-    }
-    await loadIssueDescriptions();
-    return { server };
+}
+/**
+ * Creates and initializes a Chrome DevTools MCP server instance.
+ *
+ * Maintained as a public API for backwards compatibility because external
+ * consumers and integrations rely on `createMcpServer()`. For new code,
+ * prefer using `McpServer.from(serverArgs, options)`.
+ */
+export async function createMcpServer(serverArgs, options = {}) {
+    const server = await McpServer.from(serverArgs, options);
+    return { server: server.server };
 }
 export const logDisclaimers = (args) => {
     console.error(BROWSER_EXPOSURE_DISCLAIMER);

package/build/src/processors/HeapSnapshotManager.js

@@ -7,10 +7,17 @@ import fsSync from 'node:fs';
 import path from 'node:path';
 import { DevTools } from '../third_party/index.js';
 import { createIdGenerator, stableIdSymbol, } from '../utils/id.js';
+const VALID_EXTENSIONS = ['.heapsnapshot', '.heaptimeline'];
+function hasValidHeapSnapshotExtension(filePath) {
+    return VALID_EXTENSIONS.some(ext => filePath.endsWith(ext));
+}
 export class HeapSnapshotManager {
     #snapshotIdGenerator = createIdGenerator();
     #snapshots = new Map();
     async getSnapshot(filePath) {
+        if (!hasValidHeapSnapshotExtension(filePath)) {
+            throw new Error(`File ${filePath} must have a .heapsnapshot or .heaptimeline extension.`);
+        }
         const absolutePath = path.resolve(filePath);
         const cached = this.#snapshots.get(absolutePath);
         if (cached) {
@@ -235,6 +242,11 @@ export class HeapSnapshotManager {
         const snapshot = await this.getSnapshot(filePath);
         return await snapshot.getDuplicateStrings();
     }
+    async queryObjects(filePath, options) {
+        const snapshot = await this.getSnapshot(filePath);
+        const provider = snapshot.queryObjects(options);
+        return await provider.serializeItemsRange(0, Infinity);
+    }
     hasSnapshots() {
         return this.#snapshots.size > 0;
     }

package/build/src/telemetry/ClearcutLogger.js

@@ -6,7 +6,7 @@
 import process from 'node:process';
 import { DAEMON_CLIENT_NAME } from '../daemon/utils.js';
 import { logger } from '../utils/logger.js';
-import { sanitizeParams, stripUnderscoreBeforeNumber } from './transformation.js';
+import { bucketizeDaysSince, bucketizeLatency, buildContext, sanitizeParams, stripUnderscoreBeforeNumber, } from './transformation.js';
 import { McpClient, WatchdogMessageType, OsType, } from './types.js';
 import { WatchdogClient } from './WatchdogClient.js';
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -58,7 +58,10 @@ export class ClearcutLogger {
     }
     setClientName(clientName) {
         const lowerName = clientName.toLowerCase();
-        if (lowerName.includes('claude')) {
+        if (lowerName.includes('claude-desktop')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_CLAUDE_DESKTOP;
+        }
+        else if (lowerName.includes('claude')) {
             this.#mcpClient = McpClient.MCP_CLIENT_CLAUDE_CODE;
         }
         else if (lowerName.includes('gemini')) {
@@ -70,25 +73,35 @@ export class ClearcutLogger {
         else if (lowerName.includes('openclaw')) {
             this.#mcpClient = McpClient.MCP_CLIENT_OPENCLAW;
         }
+        else if (lowerName.includes('opencode')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_OPENCODE;
+        }
         else if (lowerName.includes('codex')) {
             this.#mcpClient = McpClient.MCP_CLIENT_CODEX;
         }
         else if (lowerName.includes('antigravity')) {
             this.#mcpClient = McpClient.MCP_CLIENT_ANTIGRAVITY;
         }
+        else if (lowerName.includes('grok') || lowerName.includes('xai')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_GROK;
+        }
+        else if (lowerName.includes('copilot')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_GITHUB_COPILOT;
+        }
         else {
             this.#mcpClient = McpClient.MCP_CLIENT_OTHER;
         }
     }
     async logToolInvocation(args) {
+        const context = buildContext(args.devToolsData, args.pageUrl);
         const sanitizedToolName = stripUnderscoreBeforeNumber(args.toolName);
         const tool_invocation = {
             tool_name: sanitizedToolName,
             success: args.success,
-            latency_ms: args.latencyMs,
+            latency_ms: bucketizeLatency(args.latencyMs),
         };
-        if (Object.keys(args.context).length > 0) {
-            tool_invocation.context = args.context;
+        if (Object.keys(context).length > 0) {
+            tool_invocation.context = context;
         }
         if (Object.keys(args.params).length > 0) {
             tool_invocation.tool_params = {
@@ -130,7 +143,7 @@ export class ClearcutLogger {
                     payload: {
                         mcp_client: this.#mcpClient,
                         daily_active: {
-                            days_since_last_active: daysSince,
+                            days_since_last_active: bucketizeDaysSince(daysSince),
                         },
                     },
                 });

package/build/src/telemetry/transformation.js

@@ -13,6 +13,10 @@ export function bucketizeLatency(latencyMs) {
     }
     return LATENCY_BUCKETS[LATENCY_BUCKETS.length - 1];
 }
+export const MAX_ACTIVE_DAYS = 31;
+export function bucketizeDaysSince(days) {
+    return Math.min(days, MAX_ACTIVE_DAYS);
+}
 export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
 const SUPPORTED_ZOD_TYPES = [
     'ZodString',

package/build/src/telemetry/types.js

@@ -20,6 +20,10 @@ export var McpClient;
     McpClient[McpClient["MCP_CLIENT_OPENCLAW"] = 5] = "MCP_CLIENT_OPENCLAW";
     McpClient[McpClient["MCP_CLIENT_CODEX"] = 6] = "MCP_CLIENT_CODEX";
     McpClient[McpClient["MCP_CLIENT_ANTIGRAVITY"] = 7] = "MCP_CLIENT_ANTIGRAVITY";
+    McpClient[McpClient["MCP_CLIENT_GROK"] = 8] = "MCP_CLIENT_GROK";
+    McpClient[McpClient["MCP_CLIENT_OPENCODE"] = 9] = "MCP_CLIENT_OPENCODE";
+    McpClient[McpClient["MCP_CLIENT_CLAUDE_DESKTOP"] = 10] = "MCP_CLIENT_CLAUDE_DESKTOP";
+    McpClient[McpClient["MCP_CLIENT_GITHUB_COPILOT"] = 11] = "MCP_CLIENT_GITHUB_COPILOT";
     McpClient[McpClient["MCP_CLIENT_OTHER"] = 3] = "MCP_CLIENT_OTHER";
 })(McpClient || (McpClient = {}));
 // IPC types for messages between the main process and the

package/build/src/third_party/THIRD_PARTY_NOTICES

@@ -1,6 +1,6 @@
 Name: core-js
 URL: https://core-js.io
-Version: 3.49.0
+Version: 3.50.0
 License: MIT
 
 Copyright (c) 2013–2025 Denis Pushkarev (zloirock.ru)
@@ -745,21 +745,21 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 Name: puppeteer-core
 URL: https://github.com/puppeteer/puppeteer/tree/main/packages/puppeteer-core
-Version: 25.6.0
+Version: 25.10.0
 License: Apache-2.0
 
 -------------------- DEPENDENCY DIVIDER --------------------
 
 Name: @puppeteer/browsers
 URL: https://github.com/puppeteer/puppeteer/tree/main/packages/browsers
-Version: 3.2.0
+Version: 3.2.2
 License: Apache-2.0
 
 -------------------- DEPENDENCY DIVIDER --------------------
 
 Name: ws
 URL: https://github.com/websockets/ws
-Version: 8.21.1
+Version: 8.21.3
 License: MIT
 
 Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -795,7 +795,7 @@ License: MIT
 
 Name: devtools-frontend
 URL: https://github.com/ChromeDevTools/devtools-frontend
-Version: eaad2491924990cb310a4c753b2851e64d515f00
+Version: 2a5562dea4bfa759c15700d2311fc623c1b684d1
 License: Apache-2.0
 
 // Copyright 2014 The Chromium Authors

package/build/src/third_party/bundled-packages.json

@@ -1,10 +1,10 @@
 {
   "@modelcontextprotocol/sdk": "1.30.0",
-  "core-js": "3.49.0",
+  "core-js": "3.50.0",
   "lighthouse": "13.4.1",
   "semver": "7.8.5",
   "yargs": "18.1.0",
   "zod": "3.25.76",
-  "puppeteer-core": "25.6.0",
-  "https://github.com/ChromeDevTools/devtools-frontend": "eaad2491924990cb310a4c753b2851e64d515f00"
+  "puppeteer-core": "25.10.0",
+  "https://github.com/ChromeDevTools/devtools-frontend": "2a5562dea4bfa759c15700d2311fc623c1b684d1"
 }

package/build/src/third_party/devtools-formatter-worker.js

@@ -8557,6 +8557,16 @@ class ColorConverter {
         const rgbOutput = NAMED_GAMUTS.displayP3_INVERSE.multiply(xyzInput);
         return applyTransferFns(NAMED_TRANSFER_FN.sRGB_INVERSE, rgbOutput.values[0], rgbOutput.values[1], rgbOutput.values[2]);
     }
+    static displayP3LinearToXyzd50(r, g, b) {
+        const rgbInput = new Vector3([r, g, b]);
+        const xyzOutput = NAMED_GAMUTS.displayP3.multiply(rgbInput);
+        return xyzOutput.values;
+    }
+    static xyzd50ToDisplayP3Linear(x, y, z) {
+        const xyzInput = new Vector3([x, y, z]);
+        const rgbResult = NAMED_GAMUTS.displayP3_INVERSE.multiply(xyzInput);
+        return rgbResult.values;
+    }
     static proPhotoToXyzd50(r, g, b) {
         const [mappedR, mappedG, mappedB] = applyTransferFns(NAMED_TRANSFER_FN.proPhotoRGB, r, g, b);
         const rgbInput = new Vector3([mappedR, mappedG, mappedB]);
@@ -8756,6 +8766,8 @@ function getColorSpace(colorSpaceText) {
             return "srgb-linear" ;
         case "display-p3" :
             return "display-p3" ;
+        case "display-p3-linear" :
+            return "display-p3-linear" ;
         case "a98-rgb" :
             return "a98-rgb" ;
         case "prophoto-rgb" :
@@ -8974,6 +8986,7 @@ class Lab {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9090,6 +9103,7 @@ class LCH {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9208,6 +9222,7 @@ class Oklab {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9324,6 +9339,7 @@ class Oklch {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9443,6 +9459,7 @@ class ColorFunction {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9459,6 +9476,8 @@ class ColorFunction {
                 return ColorConverter.srgbLinearToXyzd50(p0, p1, p2);
             case "display-p3" :
                 return ColorConverter.displayP3ToXyzd50(p0, p1, p2);
+            case "display-p3-linear" :
+                return ColorConverter.displayP3LinearToXyzd50(p0, p1, p2);
             case "a98-rgb" :
                 return ColorConverter.adobeRGBToXyzd50(p0, p1, p2);
             case "prophoto-rgb" :
@@ -9614,6 +9633,7 @@ class HSL {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9741,6 +9761,7 @@ class HWB {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),
@@ -9969,6 +9990,7 @@ class Legacy {
         ["srgb" ]: (self) => new ColorFunction("srgb" , ...ColorConverter.xyzd50ToSrgb(...self.#toXyzd50()), self.alpha),
         ["srgb-linear" ]: (self) => new ColorFunction("srgb-linear" , ...ColorConverter.xyzd50TosRGBLinear(...self.#toXyzd50()), self.alpha),
         ["display-p3" ]: (self) => new ColorFunction("display-p3" , ...ColorConverter.xyzd50ToDisplayP3(...self.#toXyzd50()), self.alpha),
+        ["display-p3-linear" ]: (self) => new ColorFunction("display-p3-linear" , ...ColorConverter.xyzd50ToDisplayP3Linear(...self.#toXyzd50()), self.alpha),
         ["a98-rgb" ]: (self) => new ColorFunction("a98-rgb" , ...ColorConverter.xyzd50ToAdobeRGB(...self.#toXyzd50()), self.alpha),
         ["prophoto-rgb" ]: (self) => new ColorFunction("prophoto-rgb" , ...ColorConverter.xyzd50ToProPhoto(...self.#toXyzd50()), self.alpha),
         ["rec2020" ]: (self) => new ColorFunction("rec2020" , ...ColorConverter.xyzd50ToRec2020(...self.#toXyzd50()), self.alpha),