@netlify/edge-bundler 12.3.3 → 13.0.0

package/deno/lib/common.ts

@@ -42,7 +42,7 @@ const loadWithRetry = (specifier: string, delay = 1000, maxTry = 3) => {
       maxTry,
     });
   } catch (error) {
-    if (isTooManyTries(error)) {
+    if (isTooManyTries(error as Error)) {
       console.error(`Loading ${specifier} failed after ${maxTry} tries.`);
     }
     throw error;

package/dist/node/bridge.d.ts

@@ -1,7 +1,7 @@
 import { type WriteStream } from 'fs';
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
-declare const DENO_VERSION_RANGE = "1.39.0 - 1.46.3";
+declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
 type OnBeforeDownloadHook = () => void | Promise<void>;
 type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {
@@ -37,14 +37,16 @@ declare class DenoBridge {
     versionRange: string;
     constructor(options: DenoOptions);
     private downloadBinary;
-    private getBinaryVersion;
+    getBinaryVersion(binaryPath: string): Promise<string | undefined>;
     private getCachedBinary;
     private getGlobalBinary;
     private getRemoteBinary;
     private static runWithBinary;
     private writeVersionFile;
     ensureCacheDirectory(): Promise<void>;
-    getBinaryPath(): Promise<{
+    getBinaryPath(options?: {
+        silent?: boolean;
+    }): Promise<{
         global: boolean;
         path: string;
     }>;

package/dist/node/bridge.js

@@ -12,7 +12,7 @@ const DENO_VERSION_FILE = 'version.txt';
 // When updating DENO_VERSION_RANGE, ensure that the deno version
 // on the netlify/buildbot build image satisfies this range!
 // https://github.com/netlify/buildbot/blob/f9c03c9dcb091d6570e9d0778381560d469e78ad/build-image/noble/Dockerfile#L410
-const DENO_VERSION_RANGE = '1.39.0 - 1.46.3';
+const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
 class DenoBridge {
     constructor(options) {
         var _a, _b, _c, _d, _e;
@@ -119,15 +119,19 @@ class DenoBridge {
     async ensureCacheDirectory() {
         await fs.mkdir(this.cacheDirectory, { recursive: true });
     }
-    async getBinaryPath() {
+    async getBinaryPath(options) {
         const globalPath = await this.getGlobalBinary();
         if (globalPath !== undefined) {
-            this.logger.system('Using global installation of Deno CLI');
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                this.logger.system('Using global installation of Deno CLI');
+            }
             return { global: true, path: globalPath };
         }
         const cachedPath = await this.getCachedBinary();
         if (cachedPath !== undefined) {
-            this.logger.system('Using cached Deno CLI from', cachedPath);
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                this.logger.system('Using cached Deno CLI from', cachedPath);
+            }
             return { global: false, path: cachedPath };
         }
         const downloadedPath = await this.getRemoteBinary();

package/dist/node/bundler.test.js

@@ -84,16 +84,11 @@ test('Adds a custom error property to user errors during bundling', async () =>
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
-        const [messageBeforeStack] = error.message.split('at <anonymous> (file://');
-        expect(messageBeforeStack).toMatchInlineSnapshot(`
-      "error: Uncaught (in promise) Error: The module's source code could not be parsed: Unexpected eof at file:///root/functions/func1.ts:1:27
-
-        export default async () => 
-                                  ~
-            const ret = new Error(getStringFromWasm0(arg0, arg1));
-                        ^
-          "
-    `);
+        const messageBeforeStack = error.message;
+        expect(messageBeforeStack
+            .replace(/file:\/\/\/(.*?\/)(build\/packages\/edge-bundler\/deno\/vendor\/deno\.land\/x\/eszip.*)/, 'file://$2')
+            // eslint-disable-next-line no-control-regex
+            .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '')).toMatchSnapshot();
         expect(error.customErrorInfo).toEqual({
             location: {
                 format: 'eszip',
@@ -407,6 +402,28 @@ test('Loads npm modules from bare specifiers', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+test('Loads npm modules which use package.json.exports', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_exports');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        vendorDirectory: vendorDirectory.path,
+    });
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).toBe('hello');
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});
 test('Loads npm modules in a monorepo setup', async () => {
     const systemLogger = vi.fn();
     const { basePath: rootPath, cleanup, distPath } = await useFixture('monorepo_npm_module');

package/dist/node/config.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
+import { SemVer } from 'semver';
 import tmp from 'tmp-promise';
 import { BundleError } from './bundle_error.js';
 import { getPackagePath } from './package_json.js';
@@ -39,21 +40,23 @@ export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
     // The extractor will use its exit code to signal different error scenarios,
     // based on the list of exit codes we send as an argument. We then capture
     // the exit code to know exactly what happened and guide people accordingly.
+    const version = new SemVer((await deno.getBinaryVersion((await deno.getBinaryPath({ silent: true })).path)) || '');
     const { exitCode, stderr, stdout } = await deno.run([
         'run',
         '--allow-env',
+        version.major >= 2 ? '--allow-import' : '',
         '--allow-net',
         '--allow-read',
         `--allow-write=${collector.path}`,
-        '--quiet',
         `--import-map=${importMap.toDataURL()}`,
         '--no-config',
         '--node-modules-dir=false',
+        '--quiet',
         extractorPath,
         pathToFileURL(func.path).href,
         pathToFileURL(collector.path).href,
         JSON.stringify(ConfigExitCode),
-    ], { rejectOnExitCode: false });
+    ].filter(Boolean), { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {
         handleConfigError(func, exitCode, stderr, log);
         return {};

package/dist/node/npm_dependencies.d.ts

@@ -16,7 +16,6 @@ export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, imp
         baseURL: import("url").URL;
         imports: Record<string, string>;
     };
-    npmSpecifiersWithExtraneousFiles: string[];
     outputFiles: string[];
 }>;
 export {};

package/dist/node/npm_dependencies.js

@@ -3,13 +3,15 @@ import { builtinModules } from 'module';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { resolve } from '@import-maps/resolve';
-import { nodeFileTrace, resolve as nftResolve } from '@vercel/nft';
 import { build } from 'esbuild';
 import { findUp } from 'find-up';
-import getPackageName from 'get-package-name';
+import { parseImports } from 'parse-imports';
 import tmp from 'tmp-promise';
 import { pathsBetween } from './utils/fs.js';
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.ctsx', '.mts', '.mtsx']);
+const slugifyFileName = (specifier) => {
+    return specifier.replace(/\//g, '_');
+};
 const slugifyPackageName = (specifier) => {
     if (!specifier.startsWith('@'))
         return specifier;
@@ -55,9 +57,20 @@ const getTypesPath = async (packageJsonPath) => {
     }
     return await getTypePathFromTypesPackage(name, packageJsonPath);
 };
-const safelyDetectTypes = async (packageJsonPath) => {
+function packageName(specifier) {
+    if (!specifier.startsWith('@'))
+        return specifier.split('/')[0];
+    const [scope, pkg] = specifier.split('/');
+    return `${scope}/${pkg}`;
+}
+const safelyDetectTypes = async (pkg, basePath) => {
     try {
-        return await getTypesPath(packageJsonPath);
+        const json = await findUp(`node_modules/${packageName(pkg)}/package.json`, {
+            cwd: basePath,
+        });
+        if (json) {
+            return await getTypesPath(json);
+        }
     }
     catch {
         return undefined;
@@ -81,92 +94,80 @@ const banner = {
   globalThis.Buffer = __nfyBuffer;
   `,
 };
+async function compileTypeScript(file) {
+    const compiled = await build({
+        bundle: false,
+        entryPoints: [file],
+        logLevel: 'silent',
+        platform: 'node',
+        write: false,
+    });
+    return compiled.outputFiles[0].text;
+}
+async function parseImportsForFile(file, rootPath) {
+    const source = TYPESCRIPT_EXTENSIONS.has(path.extname(file))
+        ? await compileTypeScript(file)
+        : await fs.readFile(file, 'utf-8');
+    return await parseImports(source, {
+        resolveFrom: rootPath,
+    });
+}
 /**
  * Parses a set of functions and returns a list of specifiers that correspond
  * to npm modules.
  */
 const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, rootPath }) => {
+    var _a;
     const baseURL = pathToFileURL(basePath);
-    const { reasons } = await nodeFileTrace(functions, {
-        base: rootPath,
-        processCwd: basePath,
-        readFile: async (filePath) => {
-            // If this is a TypeScript file, we need to compile in before we can
-            // parse it.
-            if (TYPESCRIPT_EXTENSIONS.has(path.extname(filePath))) {
-                const compiled = await build({
-                    bundle: false,
-                    entryPoints: [filePath],
-                    logLevel: 'silent',
-                    platform: 'node',
-                    write: false,
-                });
-                return compiled.outputFiles[0].text;
-            }
-            return fs.readFile(filePath, 'utf8');
-        },
-        resolve: async (specifier, ...args) => {
-            // Start by checking whether the specifier matches any import map defined
-            // by the user.
-            const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
-            // If it does, the resolved import is the specifier we'll evaluate going
-            // forward.
-            if (matched && resolvedImport.protocol === 'file:') {
-                const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
-                return nftResolve(newSpecifier, ...args);
-            }
-            return nftResolve(specifier, ...args);
-        },
-    });
     const npmSpecifiers = [];
-    const npmSpecifiersWithExtraneousFiles = new Set();
-    for (const [filePath, reason] of reasons.entries()) {
-        const parents = [...reason.parents];
-        const isExtraneousFile = reason.type.every((type) => type === 'asset');
-        // An extraneous file is a dependency that was traced by NFT and marked
-        // as not being statically imported. We can't process dynamic importing
-        // at runtime, so we gather the list of modules that may use these files
-        // so that we can warn users about this caveat.
-        if (isExtraneousFile) {
-            parents.forEach((path) => {
-                const specifier = getPackageName(path);
-                if (specifier) {
-                    npmSpecifiersWithExtraneousFiles.add(specifier);
+    for (const func of functions) {
+        const imports = await parseImportsForFile(func, rootPath);
+        for (const i of imports) {
+            // The non-null assertion is required because typescript can not infer that `moduleSpecifier.value` can be narrowed to a string.
+            // The narrowing is possible because `moduleSpecifier.value` will always be a string when `moduleSpecifier.isConstant` is true.
+            const specifier = i.moduleSpecifier.isConstant ? i.moduleSpecifier.value : i.moduleSpecifier.code;
+            switch (i.moduleSpecifier.type) {
+                case 'absolute': {
+                    npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [specifier], importMap, environment, rootPath })));
+                    break;
                 }
-            });
-        }
-        // every dependency will have its `package.json` in `reasons` exactly once.
-        // by only looking at this file, we save us from doing duplicate work.
-        const isPackageJson = filePath.endsWith('package.json');
-        if (!isPackageJson)
-            continue;
-        const packageName = getPackageName(filePath);
-        if (packageName === undefined)
-            continue;
-        const isDirectDependency = parents.some((parentPath) => {
-            var _a, _b;
-            if (!parentPath.startsWith(`node_modules${path.sep}`))
-                return true;
-            // typically, edge functions have no direct dependency on the `package.json` of a module.
-            // it's the impl files that depend on `package.json`, so we need to check the parents of
-            // the `package.json` file as well to see if the module is a direct dependency.
-            const parents = [...((_b = (_a = reasons.get(parentPath)) === null || _a === void 0 ? void 0 : _a.parents) !== null && _b !== void 0 ? _b : [])];
-            return parents.some((parentPath) => !parentPath.startsWith(`node_modules${path.sep}`));
-        });
-        // We're only interested in capturing the specifiers that are first-level
-        // dependencies. Because we'll bundle all modules in a subsequent step,
-        // any transitive dependencies will be handled then.
-        if (isDirectDependency) {
-            npmSpecifiers.push({
-                specifier: packageName,
-                types: environment === 'development' ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
-            });
+                case 'relative': {
+                    const filePath = path.join(path.dirname(func), specifier);
+                    npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [filePath], importMap, environment, rootPath })));
+                    break;
+                }
+                case 'package': {
+                    // node: prefixed imports are detected as packages instead of as builtins
+                    // we don't want to try and bundle builtins so we ignore node: prefixed imports
+                    if (specifier.startsWith('node:')) {
+                        break;
+                    }
+                    const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
+                    if (matched) {
+                        if (resolvedImport.protocol === 'file:') {
+                            const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
+                            npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [newSpecifier], importMap, environment, rootPath })));
+                        }
+                    }
+                    else if (!((_a = resolvedImport === null || resolvedImport === void 0 ? void 0 : resolvedImport.protocol) === null || _a === void 0 ? void 0 : _a.startsWith('http'))) {
+                        const t = await safelyDetectTypes(specifier, basePath);
+                        npmSpecifiers.push({
+                            specifier: specifier,
+                            types: t,
+                        });
+                    }
+                    break;
+                }
+                case 'builtin':
+                case 'invalid':
+                case 'unknown': {
+                    // We don't bundle these types of modules
+                    break;
+                }
+            }
         }
     }
-    return {
-        npmSpecifiers,
-        npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
-    };
+    return npmSpecifiers;
 };
 export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, environment, rootPath = basePath, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
@@ -178,7 +179,7 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // project directory. If a custom directory has been specified, we use it.
     // Otherwise, create a random temporary directory.
     const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
-    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers({
+    const npmSpecifiers = await getNPMSpecifiers({
         basePath,
         functions,
         importMap: importMap.getContentsWithURLObjects(),
@@ -189,8 +190,8 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // where we re-export everything from that specifier. We do this for every
     // specifier, and each of these files will become entry points to esbuild.
     const ops = await Promise.all(npmSpecifiers.map(async ({ specifier, types }) => {
-        const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
-        const filePath = path.join(temporaryDirectory.path, `bundled-${slugifyPackageName(specifier)}.js`);
+        const code = `import * as mod from "${specifier}";\nexport default mod.default;\nexport * from "${specifier}";`;
+        const filePath = path.join(temporaryDirectory.path, `bundled-${slugifyFileName(specifier)}.js`);
         await fs.writeFile(filePath, code);
         return { filePath, specifier, types };
     }));
@@ -269,7 +270,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         cleanup,
         directory: temporaryDirectory.path,
         importMap: newImportMap,
-        npmSpecifiersWithExtraneousFiles,
         outputFiles,
     };
 };

package/dist/node/server/server.d.ts

@@ -39,7 +39,6 @@ export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, d
     features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: ModuleGraphJson;
-    npmSpecifiersWithExtraneousFiles: string[];
     success: boolean;
 }>>;
 export {};

package/dist/node/server/server.js

@@ -1,5 +1,6 @@
 import { readdir, unlink } from 'fs/promises';
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 import { DenoBridge } from '../bridge.js';
 import { getFunctionConfig } from '../config.js';
 import { generateStage2 } from '../formats/javascript.js';
@@ -41,7 +42,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         const features = {};
         const importMap = new ImportMap();
         await importMap.addFiles((_a = options.importMapPaths) !== null && _a !== void 0 ? _a : [], logger);
-        const npmSpecifiersWithExtraneousFiles = [];
         // we keep track of the files that are relevant to the user's code, so we can clean up leftovers from past executions later
         const relevantFiles = [stage2Path];
         const vendor = await vendorNPMSpecifiers({
@@ -56,7 +56,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         if (vendor) {
             features.npmModules = true;
             importMap.add(vendor.importMap);
-            npmSpecifiersWithExtraneousFiles.push(...vendor.npmSpecifiersWithExtraneousFiles);
             relevantFiles.push(...vendor.outputFiles);
         }
         await cleanDirectory(distDirectory, relevantFiles);
@@ -65,7 +64,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             // the `stage2Path` file as well as all of their dependencies.
             // Consumers such as the CLI can use this information to watch all the
             // relevant files and issue an isolate restart when one of them changes.
-            const { stdout } = await deno.run(['info', '--json', stage2Path]);
+            const { stdout } = await deno.run(['info', '--json', pathToFileURL(stage2Path).href]);
             graph = JSON.parse(stdout);
         }
         catch {
@@ -95,7 +94,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             features,
             functionsConfig,
             graph,
-            npmSpecifiersWithExtraneousFiles,
             success,
         };
     };

package/dist/node/server/server.test.js

@@ -42,15 +42,15 @@ test('Starts a server and serves requests for edge functions', async () => {
         getFunctionsConfig: true,
         importMapPaths,
     };
-    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
+    const { features, functionsConfig, graph, success } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
-    expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
+    const modules = graph === null || graph === void 0 ? void 0 : graph.modules.filter(({ kind, mediaType }) => kind === 'esm' && mediaType === 'TypeScript');
     for (const key in functions) {
-        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
+        const graphEntry = modules === null || modules === void 0 ? void 0 : modules.some(({ local }) => local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {
@@ -84,7 +84,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     });
     const idBarrelFile = await readFile(join(servePath, 'bundled-id.js'), 'utf-8');
     expect(idBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', 'id', 'types.d.ts')}" />`);
-    const identidadeBarrelFile = await readFile(join(servePath, 'bundled-pt-committee__identidade.js'), 'utf-8');
+    const identidadeBarrelFile = await readFile(join(servePath, 'bundled-@pt-committee_identidade.js'), 'utf-8');
     expect(identidadeBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`);
 });
 test('Serves edge functions in a monorepo setup', async () => {
@@ -116,13 +116,12 @@ test('Serves edge functions in a monorepo setup', async () => {
         getFunctionsConfig: true,
         importMapPaths,
     };
-    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
+    const { features, functionsConfig, graph, success } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/func1' }]);
-    expect(npmSpecifiersWithExtraneousFiles).toEqual(['child-1']);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);

package/dist/test/util.js

@@ -76,7 +76,7 @@ const runESZIP = async (eszipPath, vendorDirectory) => {
     }
     await fs.rename(stage2Path, `${stage2Path}.js`);
     // Run function that imports the extracted stage 2 and invokes each function.
-    const evalCommand = execa('deno', ['eval', '--no-check', '--import-map', importMapPath, inspectFunction(stage2Path)]);
+    const evalCommand = execa('deno', ['eval', '--import-map', importMapPath, inspectFunction(stage2Path)]);
     (_c = evalCommand.stderr) === null || _c === void 0 ? void 0 : _c.pipe(stderr);
     const result = await evalCommand;
     await tmpDir.cleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "12.3.3",
+  "version": "13.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -58,7 +58,6 @@
   },
   "dependencies": {
     "@import-maps/resolve": "^1.0.1",
-    "@vercel/nft": "0.27.7",
     "ajv": "^8.11.2",
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
@@ -74,11 +73,12 @@
     "node-stream-zip": "^1.15.0",
     "p-retry": "^5.1.1",
     "p-wait-for": "^5.0.0",
+    "parse-imports": "^2.2.1",
     "path-key": "^4.0.0",
     "semver": "^7.3.8",
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
   },
-  "gitHead": "e5ea1c42c57f534be1be05f544b2d7a5dbe57d87"
+  "gitHead": "8d10878db3be9cfefe3162fd155c76595aba045e"
 }