chrome-devtools-mcp 0.25.0 → 1.0.1

package/build/src/bin/chrome-devtools-cli-options.js

@@ -114,7 +114,7 @@ export const commands = {
             geolocation: {
                 name: 'geolocation',
                 type: 'string',
-                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
+                description: 'Geolocation (`<latitude>,<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
                 required: false,
             },
             userAgent: {
@@ -154,6 +154,12 @@ export const commands = {
                 description: 'An optional list of arguments to pass to the function.',
                 required: false,
             },
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.',
+                required: false,
+            },
             dialogAction: {
                 name: 'dialogAction',
                 type: 'string',
@@ -211,7 +217,7 @@ export const commands = {
             value: {
                 name: 'value',
                 type: 'string',
-                description: 'The value to fill in',
+                description: 'The value to fill in. "true" or "false" for checkboxes and toggles, "true" for radio buttons.',
                 required: true,
             },
             includeSnapshot: {
@@ -282,6 +288,36 @@ export const commands = {
             },
         },
     },
+    get_node_retainers: {
+        description: 'Loads a memory heapsnapshot and returns retainers for a specific node ID. (requires flag: --experimentalMemory=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            nodeId: {
+                name: 'nodeId',
+                type: 'number',
+                description: 'The stable node ID to get retainers for.',
+                required: true,
+            },
+            pageIdx: {
+                name: 'pageIdx',
+                type: 'number',
+                description: 'The page index for pagination.',
+                required: false,
+            },
+            pageSize: {
+                name: 'pageSize',
+                type: 'number',
+                description: 'The page size for pagination.',
+                required: false,
+            },
+        },
+    },
     get_nodes_by_class: {
         description: 'Loads a memory heapsnapshot and returns instances of a specific class with their stable IDs. (requires flag: --experimentalMemory=true)',
         category: 'Memory',

package/build/src/bin/chrome-devtools-mcp-cli-options.js

@@ -136,33 +136,27 @@ export const cliOptions = {
     },
     experimentalPageIdRouting: {
         type: 'boolean',
-        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID.',
-        hidden: true,
+        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID (useful for concurrent agent sessions).',
     },
     experimentalDevtools: {
         type: 'boolean',
         describe: 'Whether to enable automation over DevTools targets',
-        hidden: true,
     },
     experimentalVision: {
         type: 'boolean',
         describe: 'Whether to enable coordinate-based tools such as click_at(x,y). Usually requires a computer-use model able to produce accurate coordinates by looking at screenshots.',
-        hidden: false,
     },
     experimentalMemory: {
         type: 'boolean',
         describe: 'Whether to enable experimental memory tools.',
-        hidden: true,
     },
     experimentalStructuredContent: {
         type: 'boolean',
         describe: 'Whether to output structured formatted content.',
-        hidden: true,
     },
     experimentalIncludeAllPages: {
         type: 'boolean',
         describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
-        hidden: true,
     },
     experimentalNavigationAllowlist: {
         type: 'boolean',
@@ -257,7 +251,7 @@ export const cliOptions = {
     },
     redactNetworkHeaders: {
         type: 'boolean',
-        describe: 'If true, redacts some of the network headers considered senstive before returning to the client.',
+        describe: 'If true, redacts some of the network headers considered sensitive before returning to the client.',
         default: false,
     },
 };

package/build/src/bin/chrome-devtools-mcp-main.js

@@ -7,6 +7,7 @@ import '../polyfill.js';
 import process from 'node:process';
 import { createMcpServer, logDisclaimers } from '../index.js';
 import { logger, saveLogsToFile } from '../logger.js';
+import { ClearcutLogger } from '../telemetry/ClearcutLogger.js';
 import { computeFlagUsage } from '../telemetry/flagUtils.js';
 import { StdioServerTransport } from '../third_party/index.js';
 import { checkForUpdates } from '../utils/check-for-updates.js';
@@ -21,13 +22,13 @@ if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
     });
 }
 logger(`Starting Chrome DevTools MCP Server v${VERSION}`);
-const { server, clearcutLogger } = await createMcpServer(args, {
+const { server } = await createMcpServer(args, {
     logFile,
 });
 const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome DevTools MCP Server connected');
 logDisclaimers(args);
-void clearcutLogger?.logDailyActiveIfNeeded();
-void clearcutLogger?.logServerStart(computeFlagUsage(args, cliOptions));
+void ClearcutLogger.get()?.logDailyActiveIfNeeded();
+void ClearcutLogger.get()?.logServerStart(computeFlagUsage(args, cliOptions));
 //# sourceMappingURL=chrome-devtools-mcp-main.js.map

package/build/src/bin/chrome-devtools.js

@@ -24,8 +24,6 @@ const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
 const startCliOptions = {
     ...cliOptions,
 };
-// Not supported in CLI on purpose.
-delete startCliOptions.autoConnect;
 // Missing CLI serialization.
 delete startCliOptions.viewport;
 // Change the defaults for the CLI.

package/build/src/daemon/client.js

@@ -115,13 +115,8 @@ export async function handleResponse(response, format) {
     if (response.isError) {
         return JSON.stringify(response.content);
     }
-    if (format === 'json') {
-        if (response.structuredContent) {
-            return JSON.stringify(response.structuredContent);
-        }
-        // Fall-through to text for backward compatibility.
-    }
     const chunks = [];
+    const images = [];
     for (const content of response.content) {
         if (content.type === 'text') {
             chunks.push(content.text);
@@ -143,12 +138,23 @@ export async function handleResponse(response, format) {
             const name = crypto.randomUUID();
             const filepath = await getTempFilePath(`${name}${extension}`);
             fs.writeFileSync(filepath, data);
+            images.push({ filePath: filepath, mimeType });
             chunks.push(`Saved to ${filepath}.`);
         }
         else {
             throw new Error('Not supported response content type');
         }
     }
+    if (format === 'json') {
+        if (response.structuredContent) {
+            const structuredContent = {
+                ...response.structuredContent,
+                ...(images.length ? { images } : {}),
+            };
+            return JSON.stringify(structuredContent);
+        }
+        // Fall-through to text for backward compatibility.
+    }
     return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
 }
 //# sourceMappingURL=client.js.map

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -3,10 +3,22 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { DevTools } from '../third_party/index.js';
 import { stableIdSymbol } from '../utils/id.js';
 export function isNodeLike(item) {
     return (typeof item === 'object' && item !== null && 'id' in item && 'name' in item);
 }
+export function isEdgeLike(item) {
+    return (typeof item === 'object' &&
+        item !== null &&
+        'name' in item &&
+        'node' in item &&
+        'type' in item &&
+        typeof item.node === 'object' &&
+        item.node !== null &&
+        'id' in item.node &&
+        'name' in item.node);
+}
 export class HeapSnapshotFormatter {
     #aggregates;
     constructor(aggregates) {
@@ -14,12 +26,21 @@ export class HeapSnapshotFormatter {
     }
     static formatNodes(items) {
         const lines = [];
-        if (items.length > 0 && isNodeLike(items[0])) {
-            lines.push('id,name,type,distance,selfSize,retainedSize');
+        if (items.length > 0) {
+            const firstItem = items[0];
+            if (isNodeLike(firstItem)) {
+                lines.push('id,name,type,distance,selfSize,retainedSize');
+            }
+            else if (isEdgeLike(firstItem)) {
+                lines.push('edgeIndex,edgeName,edgeType,targetNodeId,targetNodeName');
+            }
         }
         for (const item of items) {
             if (isNodeLike(item)) {
-                lines.push(`${item.id},"${item.name}",${item.type},${item.distance},${item.selfSize},${item.retainedSize}`);
+                lines.push(`${item.id},${item.name},${item.type},${item.distance},${DevTools.I18n.ByteUtilities.formatBytesToKb(item.selfSize)},${DevTools.I18n.ByteUtilities.formatBytesToKb(item.retainedSize)}`);
+            }
+            else if (isEdgeLike(item)) {
+                lines.push(`${item.edgeIndex},${item.name},${item.type},${item.node.id},${item.node.name}`);
             }
         }
         return lines.join('\n');
@@ -33,7 +54,7 @@ export class HeapSnapshotFormatter {
         lines.push('uid,className,count,selfSize,maxRetainedSize');
         for (const info of sorted) {
             const uid = info[stableIdSymbol] ?? '';
-            lines.push(`${uid},"${info.name}",${info.count},${info.self},${info.maxRet}`);
+            lines.push(`${uid},${info.name},${info.count},${DevTools.I18n.ByteUtilities.formatBytesToKb(info.self)},${DevTools.I18n.ByteUtilities.formatBytesToKb(info.maxRet)}`);
         }
         return lines.join('\n');
     }
@@ -43,8 +64,8 @@ export class HeapSnapshotFormatter {
             uid: info[stableIdSymbol],
             className: info.name,
             count: info.count,
-            selfSize: info.self,
-            retainedSize: info.maxRet,
+            selfSize: DevTools.I18n.ByteUtilities.formatBytesToKb(info.self),
+            retainedSize: DevTools.I18n.ByteUtilities.formatBytesToKb(info.maxRet),
         }));
     }
     static sort(aggregates) {

package/build/src/index.js

@@ -7,77 +7,18 @@ import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
 import { loadIssueDescriptions } from './issue-descriptions.js';
 import { logger } from './logger.js';
 import { McpContext } from './McpContext.js';
-import { McpResponse } from './McpResponse.js';
 import { Mutex } from './Mutex.js';
-import { SlimMcpResponse } from './SlimMcpResponse.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
-import { bucketizeLatency } from './telemetry/metricUtils.js';
+import { FilePersistence } from './telemetry/persistence.js';
 import { McpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, } from './third_party/index.js';
-import { labels, OFF_BY_DEFAULT_CATEGORIES } from './tools/categories.js';
-import { pageIdSchema } from './tools/ToolDefinition.js';
+import { ToolHandler } from './ToolHandler.js';
 import { createTools } from './tools/tools.js';
 import { VERSION } from './version.js';
-export function buildFlag(category) {
-    return `category${category.charAt(0).toUpperCase() + category.slice(1)}`;
-}
-function buildDisabledMessage(toolName, flag, categoryLabel) {
-    const reason = categoryLabel
-        ? `is in category ${categoryLabel} which`
-        : `requires experimental feature ${flag} and`;
-    return `Tool ${toolName} ${reason} is currently disabled. Enable it by running chrome-devtools start ${flag}=true. For more information check the README.`;
-}
-function getCategoryStatus(category, serverArgs) {
-    const categoryFlag = buildFlag(category);
-    const flagValue = serverArgs[categoryFlag];
-    const isDisabled = OFF_BY_DEFAULT_CATEGORIES.includes(category)
-        ? !flagValue
-        : flagValue === false;
-    if (isDisabled) {
-        return {
-            categoryFlag,
-            disabled: true,
-        };
-    }
-    return {
-        disabled: false,
-    };
-}
-function getConditionStatus(condition, serverArgs) {
-    if (condition && !serverArgs[condition]) {
-        return { conditionFlag: condition, disabled: true };
-    }
-    return { disabled: false };
-}
-function getToolStatusInfo(tool, serverArgs) {
-    const category = tool.annotations.category;
-    const categoryCheck = getCategoryStatus(category, serverArgs);
-    if (category && categoryCheck.disabled) {
-        if (!categoryCheck.categoryFlag) {
-            throw new Error('when the category is disabled there should always be a flag set');
-        }
-        return {
-            disabled: true,
-            reason: buildDisabledMessage(tool.name, `--${categoryCheck.categoryFlag}`, labels[category]),
-        };
-    }
-    for (const condition of tool.annotations.conditions || []) {
-        const conditionCheck = getConditionStatus(condition, serverArgs);
-        if (conditionCheck.disabled) {
-            if (!conditionCheck.conditionFlag) {
-                throw new Error('when the condition is disabled there should always be a flag set');
-            }
-            return {
-                disabled: true,
-                reason: buildDisabledMessage(tool.name, `--${conditionCheck.conditionFlag}`),
-            };
-        }
-    }
-    return { disabled: false };
-}
+export { buildFlag } from './ToolHandler.js';
 export async function createMcpServer(serverArgs, options) {
-    let clearcutLogger;
     if (serverArgs.usageStatistics) {
-        clearcutLogger = new ClearcutLogger({
+        ClearcutLogger.initialize({
+            persistence: new FilePersistence(),
             logFile: serverArgs.logFile,
             appVersion: VERSION,
             clearcutEndpoint: serverArgs.clearcutEndpoint,
@@ -108,7 +49,7 @@ export async function createMcpServer(serverArgs, options) {
     server.server.oninitialized = () => {
         const clientName = server.server.getClientVersion()?.name;
         if (clientName) {
-            clearcutLogger?.setClientName(clientName);
+            ClearcutLogger.get()?.setClientName(clientName);
         }
         if (server.server.getClientCapabilities()?.roots) {
             void updateRoots();
@@ -164,110 +105,16 @@ export async function createMcpServer(serverArgs, options) {
     }
     const toolMutex = new Mutex();
     function registerTool(tool) {
-        const { disabled, reason: disabledReason } = getToolStatusInfo(tool, serverArgs);
-        if (disabled && !serverArgs.viaCli) {
+        const toolHandler = new ToolHandler(tool, serverArgs, getContext, toolMutex);
+        if (!toolHandler.shouldRegister) {
             return;
         }
-        const schema = 'pageScoped' in tool &&
-            tool.pageScoped &&
-            serverArgs.experimentalPageIdRouting &&
-            !serverArgs.slim
-            ? { ...tool.schema, ...pageIdSchema }
-            : tool.schema;
         server.registerTool(tool.name, {
             description: tool.description,
-            inputSchema: schema,
+            inputSchema: toolHandler.registeredInputSchema,
             annotations: tool.annotations,
         }, async (params) => {
-            if (disabledReason) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: disabledReason,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const guard = await toolMutex.acquire();
-            const startTime = Date.now();
-            let success = false;
-            try {
-                logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
-                const context = await getContext();
-                logger(`${tool.name} context: resolved`);
-                await context.detectOpenDevToolsWindows();
-                const response = serverArgs.slim
-                    ? new SlimMcpResponse(serverArgs)
-                    : new McpResponse(serverArgs);
-                response.setRedactNetworkHeaders(serverArgs.redactNetworkHeaders);
-                try {
-                    const page = serverArgs.experimentalPageIdRouting &&
-                        params.pageId &&
-                        !serverArgs.slim
-                        ? context.getPageById(params.pageId)
-                        : context.getSelectedMcpPage();
-                    response.setPage(page);
-                    if (tool.blockedByDialog) {
-                        page.throwIfDialogOpen();
-                    }
-                    if ('pageScoped' in tool && tool.pageScoped) {
-                        await tool.handler({
-                            params,
-                            page,
-                        }, response, context);
-                    }
-                    else {
-                        await tool.handler(
-                        // @ts-expect-error types do not match.
-                        {
-                            params,
-                        }, response, context);
-                    }
-                }
-                catch (err) {
-                    response.setError(err);
-                }
-                const { content, structuredContent } = await response.handle(tool.name, context);
-                const result = {
-                    content,
-                };
-                if (response.error) {
-                    result.isError = true;
-                }
-                success = true;
-                if (serverArgs.experimentalStructuredContent) {
-                    result.structuredContent = structuredContent;
-                }
-                return result;
-            }
-            catch (err) {
-                logger(`${tool.name} error:`, err, err?.stack);
-                let errorText = err && 'message' in err ? err.message : String(err);
-                if ('cause' in err && err.cause) {
-                    errorText += `\nCause: ${err.cause.message}`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: errorText,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            finally {
-                void clearcutLogger?.logToolInvocation({
-                    toolName: tool.name,
-                    params,
-                    schema,
-                    success,
-                    latencyMs: bucketizeLatency(Date.now() - startTime),
-                });
-                guard.dispose();
-            }
+            return await toolHandler.handle(params);
         });
     }
     const tools = createTools(serverArgs);
@@ -275,7 +122,7 @@ export async function createMcpServer(serverArgs, options) {
         registerTool(tool);
     }
     await loadIssueDescriptions();
-    return { server, clearcutLogger };
+    return { server };
 }
 export const logDisclaimers = (args) => {
     console.error(`chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,

package/build/src/telemetry/ClearcutLogger.js

@@ -6,124 +6,10 @@
 import process from 'node:process';
 import { DAEMON_CLIENT_NAME } from '../daemon/utils.js';
 import { logger } from '../logger.js';
-import { FilePersistence } from './persistence.js';
+import { 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;
-export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
-const SUPPORTED_ZOD_TYPES = [
-    'ZodString',
-    'ZodNumber',
-    'ZodBoolean',
-    'ZodArray',
-    'ZodEnum',
-];
-function isZodType(type) {
-    return SUPPORTED_ZOD_TYPES.includes(type);
-}
-export function getZodType(zodType) {
-    const def = zodType._def;
-    const typeName = def.typeName;
-    if (typeName === 'ZodOptional' ||
-        typeName === 'ZodDefault' ||
-        typeName === 'ZodNullable') {
-        return getZodType(def.innerType);
-    }
-    if (typeName === 'ZodEffects') {
-        return getZodType(def.schema);
-    }
-    if (isZodType(typeName)) {
-        return typeName;
-    }
-    throw new Error(`Unsupported zod type for tool parameter: ${typeName}`);
-}
-export function transformArgName(zodType, name) {
-    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-    if (zodType === 'ZodString') {
-        return `${snakeCaseName}_length`;
-    }
-    else if (zodType === 'ZodArray') {
-        return `${snakeCaseName}_count`;
-    }
-    else {
-        return snakeCaseName;
-    }
-}
-export function transformArgType(zodType) {
-    if (zodType === 'ZodString' || zodType === 'ZodArray') {
-        return 'number';
-    }
-    switch (zodType) {
-        case 'ZodNumber':
-            return 'number';
-        case 'ZodBoolean':
-            return 'boolean';
-        case 'ZodEnum':
-            return 'enum';
-        default:
-            throw new Error(`Unsupported zod type for tool parameter: ${zodType}`);
-    }
-}
-const BUCKETS = [
-    0, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000,
-];
-function bucketize(value) {
-    for (const bucket of BUCKETS) {
-        if (bucket >= value) {
-            return bucket;
-        }
-    }
-    return BUCKETS[BUCKETS.length - 1];
-}
-function transformValue(zodType, value) {
-    if (zodType === 'ZodString') {
-        return bucketize(value.length);
-    }
-    else if (zodType === 'ZodArray') {
-        return value.length;
-    }
-    else {
-        return value;
-    }
-}
-function hasEquivalentType(zodType, value) {
-    if (zodType === 'ZodString') {
-        return typeof value === 'string';
-    }
-    else if (zodType === 'ZodArray') {
-        return Array.isArray(value);
-    }
-    else if (zodType === 'ZodNumber') {
-        return typeof value === 'number';
-    }
-    else if (zodType === 'ZodBoolean') {
-        return typeof value === 'boolean';
-    }
-    else if (zodType === 'ZodEnum') {
-        return (typeof value === 'string' ||
-            typeof value === 'number' ||
-            typeof value === 'boolean');
-    }
-    else {
-        return false;
-    }
-}
-export function sanitizeParams(params, schema) {
-    const transformed = {};
-    for (const [name, value] of Object.entries(params)) {
-        if (PARAM_BLOCKLIST.has(name)) {
-            continue;
-        }
-        const zodType = getZodType(schema[name]);
-        if (!hasEquivalentType(zodType, value)) {
-            throw new Error(`parameter ${name} has type ${zodType} but value ${value} is not of equivalent type`);
-        }
-        const transformedName = transformArgName(zodType, name);
-        const transformedValue = transformValue(zodType, value);
-        transformed[transformedName] = transformedValue;
-    }
-    return transformed;
-}
 function detectOsType() {
     switch (process.platform) {
         case 'win32':
@@ -136,12 +22,27 @@ function detectOsType() {
             return OsType.OS_TYPE_UNSPECIFIED;
     }
 }
+// Not const to allow resetting the instance for testing purposes.
+let _clearcut_logger_instance;
 export class ClearcutLogger {
     #persistence;
     #watchdog;
     #mcpClient;
+    static initialize(options) {
+        if (_clearcut_logger_instance) {
+            throw new Error('ClearcutLogger is already initialized');
+        }
+        _clearcut_logger_instance = new ClearcutLogger(options);
+        return _clearcut_logger_instance;
+    }
+    static get() {
+        return _clearcut_logger_instance;
+    }
+    static resetForTesting() {
+        _clearcut_logger_instance = undefined;
+    }
     constructor(options) {
-        this.#persistence = options.persistence ?? new FilePersistence();
+        this.#persistence = options.persistence;
         this.#watchdog =
             options.watchdogClient ??
                 new WatchdogClient({
@@ -180,14 +81,15 @@ export class ClearcutLogger {
         }
     }
     async logToolInvocation(args) {
+        const sanitizedToolName = stripUnderscoreBeforeNumber(args.toolName);
         const tool_invocation = {
-            tool_name: args.toolName,
+            tool_name: sanitizedToolName,
             success: args.success,
             latency_ms: args.latencyMs,
         };
         if (Object.keys(args.params).length > 0) {
             tool_invocation.tool_params = {
-                [`${args.toolName}_params`]: sanitizeParams(args.params, args.schema),
+                [`${sanitizedToolName}_params`]: sanitizeParams(args.params, args.schema),
             };
         }
         this.#watchdog.send({
@@ -237,6 +139,20 @@ export class ClearcutLogger {
             logger('Error in logDailyActiveIfNeeded:', err);
         }
     }
+    async logServerError(args) {
+        this.#watchdog.send({
+            type: WatchdogMessageType.LOG_EVENT,
+            payload: {
+                mcp_client: this.#mcpClient,
+                server_error: {
+                    tool_name: args.toolName
+                        ? stripUnderscoreBeforeNumber(args.toolName)
+                        : '',
+                    error_code: args.errorCode,
+                },
+            },
+        });
+    }
     #shouldLogDailyActive(state) {
         if (!state.lastActive) {
             return true;

package/build/src/telemetry/errors.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * IMPORTANT:
+ *   1. this module must only contain ErrorCode.
+ *   2. do not refactor ErrorCode to elsewhere.
+ *   3. prefix new enum values with "ERROR_CODE_". This makes it easier to
+ *      programmtically parse this file.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["ERROR_CODE_UNSPECIFIED"] = 0] = "ERROR_CODE_UNSPECIFIED";
+    ErrorCode[ErrorCode["ERROR_CODE_PERSISTENCE_FILE_READ_FAILED"] = 1] = "ERROR_CODE_PERSISTENCE_FILE_READ_FAILED";
+    ErrorCode[ErrorCode["ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED"] = 2] = "ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED";
+})(ErrorCode || (ErrorCode = {}));
+//# sourceMappingURL=errors.js.map