@netlify/edge-bundler 11.3.0 → 12.0.0

package/deno/lib/stage2.test.ts

@@ -0,0 +1,58 @@
+import { assertEquals, assertStringIncludes } from 'https://deno.land/std@0.177.0/testing/asserts.ts'
+
+import { join } from 'https://deno.land/std@0.177.0/path/mod.ts'
+import { pathToFileURL } from 'https://deno.land/std@0.177.0/node/url.ts'
+
+import { getStage2Entry } from './stage2.ts'
+import { virtualRoot } from './consts.ts'
+
+Deno.test('`getStage2Entry` returns a valid stage 2 file', async () => {
+  const directory = await Deno.makeTempDir()
+  const functions = [
+    {
+      name: 'func1',
+      path: join(directory, 'func1.ts'),
+      response: 'Hello from function 1',
+    },
+    {
+      name: 'func2',
+      path: join(directory, 'func2.ts'),
+      response: 'Hello from function 2',
+    },
+  ]
+
+  for (const func of functions) {
+    const contents = `export default async () => new Response(${JSON.stringify(func.response)})`
+
+    await Deno.writeTextFile(func.path, contents)
+  }
+
+  const baseURL = pathToFileURL(directory)
+  const stage2 = getStage2Entry(
+    directory,
+    functions.map(({ name, path }) => ({ name, path })),
+  )
+
+  // Ensuring that the stage 2 paths have the virtual root before we strip it.
+  assertStringIncludes(stage2, virtualRoot)
+
+  // Replacing the virtual root with the URL of the temporary directory so that
+  // we can actually import the module.
+  const normalizedStage2 = stage2.replaceAll(virtualRoot, `${baseURL.href}/`)
+
+  const stage2Path = join(directory, 'stage2.ts')
+  const stage2URL = pathToFileURL(stage2Path)
+
+  await Deno.writeTextFile(stage2Path, normalizedStage2)
+
+  const mod = await import(stage2URL.href)
+
+  await Deno.remove(directory, { recursive: true })
+
+  for (const func of functions) {
+    const result = await mod.functions[func.name]()
+
+    assertEquals(await result.text(), func.response)
+    assertEquals(mod.metadata.functions[func.name].url, pathToFileURL(func.path).toString())
+  }
+})

package/dist/node/bridge.js

@@ -157,7 +157,6 @@ class DenoBridge {
         const options = { env, extendEnv };
         const ps = DenoBridge.runWithBinary(binaryPath, args, { options, pipeOutput, stderr, stdout });
         if (ref !== undefined) {
-            // eslint-disable-next-line no-param-reassign
             ref.ps = ps;
         }
     }

package/dist/node/bundle_error.js

@@ -21,7 +21,6 @@ class BundleError extends Error {
 const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
         if (input.message.includes("The module's source code could not be parsed")) {
-            // eslint-disable-next-line no-param-reassign
             input.message = input.stderr;
         }
         return new BundleError(input, options);

package/dist/node/config.d.ts

@@ -2,6 +2,7 @@ import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
+import { RateLimit } from './rate_limit.js';
 export declare const enum Cache {
     Off = "off",
     Manual = "manual"
@@ -18,6 +19,7 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
     method?: HTTPMethod | HTTPMethod[];
+    rateLimit?: RateLimit;
 }
 export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
     func: EdgeFunction;

package/dist/node/config.test.js

@@ -9,6 +9,7 @@ import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
 import { ImportMap } from './import_map.js';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -64,7 +65,7 @@ const functions = [
     },
     {
         testName: 'config with wrong onError',
-        name: 'func7',
+        name: 'func6',
         source: `
       export default async () => new Response("Hello from function two")
       export const config = { onError: "foo" }
@@ -74,7 +75,7 @@ const functions = [
     {
         testName: 'config with `path`',
         expectedConfig: { path: '/home' },
-        name: 'func6',
+        name: 'func7',
         source: `
         export default async () => new Response("Hello from function three")
 
@@ -89,17 +90,74 @@ const functions = [
             name: 'a displayName',
             onError: 'bypass',
         },
-        name: 'func6',
+        name: 'func8',
         source: `
         export default async () => new Response("Hello from function three")
 
-        export const config = { path: "/home",
+        export const config = {
+          path: "/home",
           generator: '@netlify/fake-plugin@1.0.0',
           name: 'a displayName',
           onError: 'bypass',
         }
       `,
     },
+    {
+        testName: 'config with ratelimit',
+        expectedConfig: {
+            path: '/ratelimit',
+            name: 'a limit rate',
+            rateLimit: {
+                windowSize: 10,
+                windowLimit: 100,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/ratelimit",
+          rateLimit: {
+            windowSize: 10,
+            windowLimit: 100,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rate',
+        }
+      `,
+    },
+    {
+        testName: 'config with rewrite',
+        expectedConfig: {
+            path: '/rewrite',
+            name: 'a limit rewrite',
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/rewritten',
+                windowSize: 20,
+                windowLimit: 200,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/rewrite",
+          rateLimit: {
+            action: "rewrite",
+            to: "/rewritten",
+            windowSize: 20,
+            windowLimit: 200,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rewrite',
+        }
+      `,
+    },
 ];
 describe('`getFunctionConfig` extracts configuration properties from function file', () => {
     test.each(functions)('$testName', async (func) => {

package/dist/node/declaration.js

@@ -37,6 +37,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
         }
         else {
             // With an in-source config without a path, add the config to the declaration.
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             const { path, excludedPath, ...rest } = config;
             declarations.push({ ...declaration, ...rest });
         }

package/dist/node/downloader.test.js

@@ -26,7 +26,6 @@ const streamError = () => {
 };
 beforeEach(async (ctx) => {
     const tmpDir = await tmp.dir();
-    // eslint-disable-next-line no-param-reassign
     ctx.tmpDir = tmpDir.path;
 });
 afterEach(async (ctx) => {

package/dist/node/finder.js

@@ -23,7 +23,6 @@ const findFunctionInDirectory = async (directory) => {
     for (const candidatePath of candidatePaths) {
         try {
             const stats = await fs.stat(candidatePath);
-            // eslint-disable-next-line max-depth
             if (stats.isFile()) {
                 functionPath = candidatePath;
                 break;

package/dist/node/manifest.d.ts

@@ -11,11 +11,30 @@ interface Route {
     path?: string;
     methods?: string[];
 }
+interface TrafficRules {
+    action: {
+        type: string;
+        config: {
+            rate_limit_config: {
+                algorithm: string;
+                window_size: number;
+                window_limit: number;
+            };
+            aggregate: {
+                keys: {
+                    type: string;
+                }[];
+            };
+            to?: string;
+        };
+    };
+}
 export interface EdgeFunctionConfig {
     excluded_patterns: string[];
     on_error?: string;
     generator?: string;
     name?: string;
+    traffic_rules?: TrafficRules;
 }
 interface Manifest {
     bundler_version: string;

package/dist/node/manifest.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { wrapBundleError } from './bundle_error.js';
 import { normalizePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
+import { RateLimitAction, RateLimitAlgorithm, RateLimitAggregator } from './rate_limit.js';
 import { nonNullable } from './utils/non_nullable.js';
 import { ExtendedURLPattern } from './utils/urlpattern.js';
 const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
@@ -52,21 +53,31 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
     const routedFunctions = new Set();
     const declarationsWithoutFunction = new Set();
-    for (const [name, { excludedPath, onError }] of Object.entries(userFunctionConfig)) {
+    for (const [name, { excludedPath, onError, rateLimit }] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+        };
     }
-    for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const [name, { excludedPath, path, onError, rateLimit, ...rest }] of Object.entries(internalFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+            ...rest,
+        };
     }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
@@ -116,6 +127,29 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
     return { declarationsWithoutFunction: [...declarationsWithoutFunction], manifest, unroutedFunctions };
 };
+const getTrafficRulesConfig = (rl) => {
+    if (rl === undefined) {
+        return;
+    }
+    const rateLimitAgg = Array.isArray(rl.aggregateBy) ? rl.aggregateBy : [RateLimitAggregator.Domain];
+    const rewriteConfig = 'to' in rl && typeof rl.to === 'string' ? { to: rl.to } : undefined;
+    return {
+        action: {
+            type: rl.action || RateLimitAction.Limit,
+            config: {
+                ...rewriteConfig,
+                rate_limit_config: {
+                    window_limit: rl.windowLimit,
+                    window_size: rl.windowSize,
+                    algorithm: RateLimitAlgorithm.SlidingWindow,
+                },
+                aggregate: {
+                    keys: rateLimitAgg.map((agg) => ({ type: agg })),
+                },
+            },
+        },
+    };
+};
 const pathToRegularExpression = (path) => {
     if (!path) {
         return null;

package/dist/node/manifest.test.js

@@ -1,9 +1,11 @@
-import { env } from 'process';
 import { test, expect } from 'vitest';
+// @ts-expect-error current tsconfig.json doesn't allow this, but I don't want to change it
+import { version } from '../package.json' assert { type: 'json' };
 import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
 import { BundleError } from './bundle_error.js';
 import { generateManifest } from './manifest.js';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 test('Generates a manifest with different bundles', () => {
     const bundle1 = {
         extension: '.ext1',
@@ -25,7 +27,7 @@ test('Generates a manifest with different bundles', () => {
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
 });
 test('Generates a manifest with display names', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
@@ -46,7 +48,7 @@ test('Generates a manifest with display names', () => {
         'func-1': { name: 'Display Name' },
     });
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
 });
 test('Generates a manifest with a generator field', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
@@ -100,7 +102,7 @@ test('Generates a manifest with excluded paths and patterns', () => {
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({});
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
     const matcher = getRouteMatcher(manifest);
     expect((_a = matcher('/f1/hello')) === null || _a === void 0 ? void 0 : _a.function).toBe('func-1');
     expect((_b = matcher('/grandparent/parent/child/grandchild.html')) === null || _b === void 0 ? void 0 : _b.function).toBeUndefined();
@@ -122,7 +124,7 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
     });
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
 });
 test('Filters out internal in-source configurations in user created functions', () => {
     const functions = [
@@ -311,7 +313,7 @@ test('Generates a manifest without bundles', () => {
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.bundles).toEqual([]);
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
 });
 test('Generates a manifest with pre and post-cache routes', () => {
     const bundle1 = {
@@ -349,7 +351,7 @@ test('Generates a manifest with pre and post-cache routes', () => {
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedPreCacheRoutes);
     expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    expect(manifest.bundler_version).toBe(version);
 });
 test('Generates a manifest with layers', () => {
     const functions = [
@@ -433,3 +435,82 @@ test('Returns functions without a declaration and unrouted functions', () => {
     expect(declarationsWithoutFunction).toEqual(['func-3']);
     expect(unroutedFunctions).toEqual(['func-2', 'func-4']);
 });
+test('Generates a manifest with rate limit config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': { rateLimit: { windowLimit: 100, windowSize: 60 } },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rate_limit',
+                    config: {
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});
+test('Generates a manifest with rewrite config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': {
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/new_path',
+                windowLimit: 100,
+                windowSize: 60,
+                aggregateBy: [RateLimitAggregator.Domain, RateLimitAggregator.IP],
+            },
+        },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rewrite',
+                    config: {
+                        to: '/new_path',
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }, { type: 'ip' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});

package/dist/node/npm_dependencies.js

@@ -105,7 +105,6 @@ const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, r
             }
             return fs.readFile(filePath, 'utf8');
         },
-        // eslint-disable-next-line require-await
         resolve: async (specifier, ...args) => {
             // Start by checking whether the specifier matches any import map defined
             // by the user.

package/dist/node/rate_limit.d.ts

@@ -0,0 +1,25 @@
+export declare enum RateLimitAlgorithm {
+    SlidingWindow = "sliding_window"
+}
+export declare enum RateLimitAggregator {
+    Domain = "domain",
+    IP = "ip"
+}
+export declare enum RateLimitAction {
+    Limit = "rate_limit",
+    Rewrite = "rewrite"
+}
+interface SlidingWindow {
+    windowLimit: number;
+    windowSize: number;
+}
+export type RewriteActionConfig = SlidingWindow & {
+    to: string;
+};
+interface RateLimitConfig {
+    action?: RateLimitAction;
+    aggregateBy?: RateLimitAggregator | RateLimitAggregator[];
+    algorithm?: RateLimitAlgorithm;
+}
+export type RateLimit = RateLimitConfig & (SlidingWindow | RewriteActionConfig);
+export {};

package/dist/node/rate_limit.js

@@ -0,0 +1,14 @@
+export var RateLimitAlgorithm;
+(function (RateLimitAlgorithm) {
+    RateLimitAlgorithm["SlidingWindow"] = "sliding_window";
+})(RateLimitAlgorithm || (RateLimitAlgorithm = {}));
+export var RateLimitAggregator;
+(function (RateLimitAggregator) {
+    RateLimitAggregator["Domain"] = "domain";
+    RateLimitAggregator["IP"] = "ip";
+})(RateLimitAggregator || (RateLimitAggregator = {}));
+export var RateLimitAction;
+(function (RateLimitAction) {
+    RateLimitAction["Limit"] = "rate_limit";
+    RateLimitAction["Rewrite"] = "rewrite";
+})(RateLimitAction || (RateLimitAction = {}));

package/dist/node/server/util.js

@@ -14,7 +14,6 @@ const isServerReady = async (port, successRef, ps) => {
     }
     try {
         await fetch(`http://127.0.0.1:${port}`);
-        // eslint-disable-next-line no-param-reassign
         successRef.success = true;
     }
     catch {

package/dist/node/types.js

@@ -4,6 +4,7 @@ import fetch from 'node-fetch';
 const TYPES_URL = 'https://edge.netlify.com';
 const ensureLatestTypes = async (deno, logger, customTypesURL) => {
     const typesURL = customTypesURL !== null && customTypesURL !== void 0 ? customTypesURL : TYPES_URL;
+    // eslint-disable-next-line prefer-const
     let [localVersion, remoteVersion] = [await getLocalVersion(deno), ''];
     try {
         remoteVersion = await getRemoteVersion(typesURL);

package/dist/node/utils/error.js

@@ -1,4 +1,2 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const isNodeError = (error) => error instanceof Error;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const isFileNotFoundError = (error) => isNodeError(error) && error.code === 'ENOENT';

package/dist/node/validation/manifest/index.js

@@ -31,5 +31,4 @@ export const validateManifest = (manifestData, _featureFlags = {}) => {
         throw new ManifestValidationError(errorOutput);
     }
 };
-// eslint-disable-next-line unicorn/prefer-export-from
 export { ManifestValidationError };

package/dist/node/validation/manifest/index.test.js

@@ -5,7 +5,6 @@ import { validateManifest, ManifestValidationError } from './index.js';
 // This only works if this is the same instance of chalk that better-ajv-errors uses
 chalk.level = 0;
 // Factory so we have a new object per test
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getBaseManifest = () => ({
     bundles: [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "11.3.0",
+  "version": "12.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -15,20 +15,10 @@
   "scripts": {
     "build": "tsc",
     "build:dev": "tsc -w",
-    "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
-    "prepublishOnly": "npm ci && npm test",
     "prepack": "npm run build",
-    "test": "run-s build format test:dev",
-    "format": "run-s format:check-fix:*",
-    "format:ci": "run-s format:check:*",
-    "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
-    "format:check:lint": "cross-env-shell eslint $npm_package_config_eslint",
-    "format:fix:lint": "cross-env-shell eslint --fix $npm_package_config_eslint",
-    "format:check-fix:prettier": "run-e format:check:prettier format:fix:prettier",
-    "format:check:prettier": "cross-env-shell prettier --check $npm_package_config_prettier",
-    "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
+    "test": "run-s build test:dev",
     "test:dev": "run-s test:dev:*",
-    "test:ci": "run-s test:ci:*",
+    "test:ci": "run-s test:integration test:ci:*",
     "test:dev:vitest": "vitest run",
     "test:dev:vitest:watch": "vitest watch",
     "test:dev:deno": "deno test --allow-all deno",
@@ -37,24 +27,21 @@
     "test:integration": "node --experimental-modules test/integration/test.js",
     "vendor": "deno vendor --force --output deno/vendor https://deno.land/x/eszip@v0.55.2/mod.ts https://deno.land/x/retry@v2.0.0/mod.ts https://deno.land/x/std@0.177.0/path/mod.ts"
   },
-  "config": {
-    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{node,scripts,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\"",
-    "prettier": "--ignore-path .gitignore --loglevel=warn \"{node,scripts,.github}/**/*.{js,ts,md,yml,json,html}\" \"*.{js,ts,yml,json,html}\" \".*.{js,ts,yml,json,html}\" \"!**/package-lock.json\" \"!package-lock.json\" \"!node/vendor/**\""
-  },
   "keywords": [],
   "license": "MIT",
-  "repository": "https://github.com/netlify/edge-bundler",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/netlify/build.git",
+    "directory": "packages/edge-bundler"
+  },
   "bugs": {
-    "url": "https://github.com/netlify/edge-bundler/issues"
+    "url": "https://github.com/netlify/build/issues"
   },
   "author": "Netlify Inc.",
   "directories": {
     "test": "test/node"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.0.0",
-    "@commitlint/config-conventional": "^17.0.0",
-    "@netlify/eslint-config-node": "^7.0.1",
     "@types/glob-to-regexp": "^0.4.1",
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
@@ -64,7 +51,6 @@
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
     "cross-env": "^7.0.3",
-    "husky": "^8.0.0",
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^5.0.0",
@@ -81,7 +67,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.20.0",
+    "esbuild": "0.20.2",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",
@@ -97,5 +83,6 @@
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
-  }
+  },
+  "gitHead": "cf765526c7970810cc1812ac0b2b3d9bb11ea926"
 }