wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

package/src/bundle.ts

@@ -7,19 +7,28 @@ import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
 import * as esbuild from "esbuild";
 import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
-import { getBasePath, toUrlPath } from "./paths";
+import { getBasePath } from "./paths";
 import type { Config } from "./config";
+import type { DurableObjectBindings } from "./config/environment";
 import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
+import type { SourceMapMetadata } from "./inspect";
 import type { CfModule } from "./worker";
 
-type BundleResult = {
+export const COMMON_ESBUILD_OPTIONS = {
+	// Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
+	target: "es2022",
+	loader: { ".js": "jsx", ".mjs": "jsx", ".cjs": "jsx" },
+} as const;
+
+export type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
 	resolvedEntryPointPath: string;
 	bundleType: "esm" | "commonjs";
 	stop: (() => void) | undefined;
 	sourceMapPath?: string | undefined;
+	sourceMapMetadata?: SourceMapMetadata | undefined;
 };
 
 type StaticAssetsConfig =
@@ -28,6 +37,19 @@ type StaticAssetsConfig =
 	  })
 	| undefined;
 
+/**
+ * When applying the middleware facade for service workers, we need to inject
+ * some code at the top of the final output bundle. Applying an inject too early
+ * will allow esbuild to reorder the code. Additionally, we need to make sure
+ * user code is bundled in the final esbuild step with `watch` correctly
+ * configured, so code changes are detected.
+ *
+ * This type is used as the return type for the `MiddlewareFn` type representing
+ * a facade-applying function. Returned injects should be injected with the
+ * final esbuild step.
+ */
+type EntryWithInject = Entry & { inject?: string[] };
+
 /**
  * RegExp matching against esbuild's error text when it is unable to resolve
  * a Node built-in module. If we detect this when node_compat is disabled,
@@ -57,21 +79,49 @@ export function isBuildFailure(err: unknown): err is esbuild.BuildFailure {
  * Rewrites esbuild BuildFailures for failing to resolve Node built-in modules
  * to suggest enabling Node compat as opposed to `platform: "node"`.
  */
-export function rewriteNodeCompatBuildFailure(err: esbuild.BuildFailure) {
+export function rewriteNodeCompatBuildFailure(
+	err: esbuild.BuildFailure,
+	forPages = false
+) {
 	for (const error of err.errors) {
 		const match = nodeBuiltinResolveErrorText.exec(error.text);
 		if (match !== null) {
+			const issue = `The package "${match[1]}" wasn't found on the file system but is built into node.`;
+
+			const instructionForUser = `${
+				forPages
+					? 'Add the "nodejs_compat" compatibility flag to your Pages project'
+					: 'Add "node_compat = true" to your wrangler.toml file'
+			} to enable Node.js compatibility.`;
+
 			error.notes = [
 				{
 					location: null,
-					text: `The package "${match[1]}" wasn't found on the file system but is built into node.
-Add "node_compat = true" to your wrangler.toml file to enable Node compatibility.`,
+					text: `${issue}\n${instructionForUser}`,
 				},
 			];
 		}
 	}
 }
 
+const nodejsCompatPlugin: esbuild.Plugin = {
+	name: "nodejs_compat Plugin",
+	setup(pluginBuild) {
+		pluginBuild.onResolve({ filter: /node:.*/ }, () => {
+			return { external: true };
+		});
+	},
+};
+
+const cloudflareJsPlugin: esbuild.Plugin = {
+	name: "cloudflare javascript Plugin",
+	setup(pluginBuild) {
+		pluginBuild.onResolve({ filter: /^cloudflare:.*/ }, () => {
+			return { external: true };
+		});
+	},
+};
+
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
  */
@@ -79,37 +129,55 @@ export async function bundleWorker(
 	entry: Entry,
 	destination: string,
 	options: {
+		// When `bundle` is set to false, we apply shims to the Worker, but won't pull in any imports
+		bundle?: boolean;
 		serveAssetsFromWorker: boolean;
-		assets: StaticAssetsConfig;
+		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
-		jsxFactory: string | undefined;
-		jsxFragment: string | undefined;
+		doBindings: DurableObjectBindings;
+		jsxFactory?: string;
+		jsxFragment?: string;
+		entryName?: string;
 		rules: Config["rules"];
-		watch?: esbuild.WatchMode;
-		tsconfig: string | undefined;
-		minify: boolean | undefined;
-		nodeCompat: boolean | undefined;
+		watch?: esbuild.WatchMode | boolean;
+		tsconfig?: string;
+		minify?: boolean;
+		legacyNodeCompat?: boolean;
+		nodejsCompat?: boolean;
 		define: Config["define"];
 		checkFetch: boolean;
-		services: Config["services"] | undefined;
-		workerDefinitions: WorkerRegistry | undefined;
-		firstPartyWorkerDevFacade: boolean | undefined;
+		services?: Config["services"];
+		workerDefinitions?: WorkerRegistry;
+		firstPartyWorkerDevFacade?: boolean;
 		targetConsumer: "dev" | "publish";
 		local: boolean;
-		testScheduled?: boolean | undefined;
-		experimentalLocalStubCache: boolean | undefined;
+		testScheduled?: boolean;
+		experimentalLocal?: boolean;
+		inject?: string[];
+		loader?: Record<string, string>;
+		sourcemap?: esbuild.CommonOptions["sourcemap"];
+		plugins?: esbuild.Plugin[];
+		additionalModules?: CfModule[];
+		// TODO: Rip these out https://github.com/cloudflare/workers-sdk/issues/2153
+		disableModuleCollection?: boolean;
+		isOutfile?: boolean;
+		forPages?: boolean;
 	}
 ): Promise<BundleResult> {
 	const {
+		bundle = true,
 		serveAssetsFromWorker,
 		betaD1Shims,
+		doBindings,
 		jsxFactory,
 		jsxFragment,
+		entryName,
 		rules,
 		watch,
 		tsconfig,
 		minify,
-		nodeCompat,
+		legacyNodeCompat,
+		nodejsCompat,
 		checkFetch,
 		local,
 		assets,
@@ -118,7 +186,15 @@ export async function bundleWorker(
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
-		experimentalLocalStubCache,
+		experimentalLocal,
+		inject: injectOption,
+		loader,
+		sourcemap,
+		plugins,
+		disableModuleCollection,
+		isOutfile,
+		forPages,
+		additionalModules = [],
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -127,7 +203,7 @@ export async function bundleWorker(
 	const tmpDir = await tmp.dir({ unsafeCleanup: true });
 
 	const entryDirectory = path.dirname(entry.file);
-	const moduleCollector = createModuleCollector({
+	let moduleCollector = createModuleCollector({
 		wrangler1xlegacyModuleReferences: {
 			rootDirectory: entryDirectory,
 			fileNames: new Set(
@@ -143,6 +219,15 @@ export async function bundleWorker(
 		format: entry.format,
 		rules,
 	});
+	if (disableModuleCollection) {
+		moduleCollector = {
+			modules: [],
+			plugin: {
+				name: moduleCollector.plugin.name,
+				setup: () => {},
+			},
+		};
+	}
 
 	// In dev, we want to patch `fetch()` with a special version that looks
 	// for bad usages and can warn the user about them; so we inject
@@ -177,8 +262,29 @@ export async function bundleWorker(
 			path: "templates/middleware/middleware-scheduled.ts",
 		});
 	}
+	if (experimentalLocal) {
+		// In Miniflare 3, we bind the user's worker as a service binding in a
+		// special entry worker that handles things like injecting `Request.cf`,
+		// live-reload, and the pretty-error page.
+		//
+		// Unfortunately, due to a bug in `workerd`, errors thrown asynchronously by
+		// native APIs don't have `stack`s. This means Miniflare can't extract the
+		// `stack` trace from dispatching to the user worker service binding by
+		// `try/catch`.
+		//
+		// As a stop-gap solution, if the `MF-Experimental-Error-Stack` header is
+		// truthy on responses, the body will be interpreted as a JSON-error of the
+		// form `{ message?: string, name?: string, stack?: string }`.
+		//
+		// This middleware wraps the user's worker in a `try/catch`, and rewrites
+		// errors in this format so a pretty-error page can be shown.
+		middlewareToLoad.push({
+			path: "templates/middleware/middleware-miniflare3-json-error.ts",
+			dev: true,
+		});
+	}
 
-	type MiddlewareFn = (arg0: Entry) => Promise<Entry>;
+	type MiddlewareFn = (currentEntry: Entry) => Promise<EntryWithInject>;
 	const middleware: (false | undefined | MiddlewareFn)[] = [
 		// serve static assets
 		serveAssetsFromWorker &&
@@ -215,7 +321,13 @@ export async function bundleWorker(
 		Array.isArray(betaD1Shims) &&
 			betaD1Shims.length > 0 &&
 			((currentEntry: Entry) => {
-				return applyD1BetaFacade(currentEntry, tmpDir.path, betaD1Shims, local);
+				return applyD1BetaFacade(
+					currentEntry,
+					tmpDir.path,
+					betaD1Shims,
+					local && !experimentalLocal,
+					doBindings
+				);
 			}),
 
 		// Middleware loader: to add middleware, we add the path to the middleware
@@ -239,68 +351,68 @@ export async function bundleWorker(
 						(m) =>
 							(targetConsumer === "dev" && m.dev !== false) ||
 							(m.publish && targetConsumer === "publish")
-					),
-					moduleCollector.plugin
+					)
 				);
 			}),
 	].filter(Boolean);
 
-	let inputEntry = entry;
+	const inject: string[] = injectOption ?? [];
+	if (checkFetch) inject.push(checkedFetchFileToInject);
 
+	let inputEntry: EntryWithInject = entry;
 	for (const middlewareFn of middleware as MiddlewareFn[]) {
 		inputEntry = await middlewareFn(inputEntry);
+		if (inputEntry.inject !== undefined) inject.push(...inputEntry.inject);
 	}
 
 	// At this point, inputEntry points to the entry point we want to build.
 
-	const inject: string[] = [];
-	if (checkFetch) inject.push(checkedFetchFileToInject);
-	if (experimentalLocalStubCache) {
-		inject.push(
-			path.resolve(getBasePath(), "templates/experimental-local-cache-stubs.js")
-		);
-	}
-
 	const buildOptions: esbuild.BuildOptions & { metafile: true } = {
 		entryPoints: [inputEntry.file],
-		bundle: true,
+		bundle,
 		absWorkingDir: entry.directory,
 		outdir: destination,
+		entryNames: entryName || path.parse(entry.file).name,
+		...(isOutfile
+			? {
+					outdir: undefined,
+					outfile: destination,
+					entryNames: undefined,
+			  }
+			: {}),
 		inject,
-		external: ["__STATIC_CONTENT_MANIFEST"],
+		external: bundle ? ["__STATIC_CONTENT_MANIFEST"] : undefined,
 		format: entry.format === "modules" ? "esm" : "iife",
-		target: "es2020",
-		sourcemap: true,
+		target: COMMON_ESBUILD_OPTIONS.target,
+		sourcemap: sourcemap ?? true,
 		// Include a reference to the output folder in the sourcemap.
 		// This is omitted by default, but we need it to properly resolve source paths in error output.
 		sourceRoot: destination,
 		minify,
 		metafile: true,
-		conditions: ["worker", "browser"],
+		conditions: ["workerd", "worker", "browser"],
 		...(process.env.NODE_ENV && {
 			define: {
 				// use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
-				// when we do a build of wrangler. (re: https://github.com/cloudflare/wrangler2/issues/1477)
+				// when we do a build of wrangler. (re: https://github.com/cloudflare/workers-sdk/issues/1477)
 				"process.env.NODE_ENV": `"${process.env["NODE_ENV" + ""]}"`,
-				...(nodeCompat ? { global: "globalThis" } : {}),
+				...(legacyNodeCompat ? { global: "globalThis" } : {}),
 				...(checkFetch ? { fetch: "checkedFetch" } : {}),
 				...options.define,
 			},
 		}),
 		loader: {
-			".js": "jsx",
-			".mjs": "jsx",
-			".cjs": "jsx",
+			...COMMON_ESBUILD_OPTIONS.loader,
+			...(loader || {}),
 		},
 		plugins: [
-			// We run the moduleCollector plugin for service workers as part of the middleware loader
-			// so we only run here for modules or with no middleware to load
-			...(entry.format === "modules" || middlewareToLoad.length === 0
-				? [moduleCollector.plugin]
-				: []),
-			...(nodeCompat
+			moduleCollector.plugin,
+			...(legacyNodeCompat
 				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
 				: []),
+			...(nodejsCompat ? [nodejsCompatPlugin] : []),
+			...[cloudflareJsPlugin],
+			...(plugins || []),
 		],
 		...(jsxFactory && { jsxFactory }),
 		...(jsxFragment && { jsxFragment }),
@@ -315,7 +427,8 @@ export async function bundleWorker(
 	try {
 		result = await esbuild.build(buildOptions);
 	} catch (e) {
-		if (!nodeCompat && isBuildFailure(e)) rewriteNodeCompatBuildFailure(e);
+		if (!legacyNodeCompat && isBuildFailure(e))
+			rewriteNodeCompatBuildFailure(e, forPages);
 		throw e;
 	}
 
@@ -341,16 +454,39 @@ export async function bundleWorker(
 		_path.includes(".map")
 	)[0];
 
+	const resolvedEntryPointPath = path.resolve(
+		entry.directory,
+		entryPointOutputs[0][0]
+	);
+
+	// A collision between additionalModules and moduleCollector.modules is incredibly unlikely because moduleCollector hashes the modules it collects.
+	// However, if it happens, let's trust the explicitly provided additionalModules over the ones we discovered.
+	const modules = dedupeModulesByName([
+		...moduleCollector.modules,
+		...additionalModules,
+	]);
+
+	// copy all referenced modules into the output bundle directory
+	for (const module of modules) {
+		const modulePath = path.join(
+			path.dirname(resolvedEntryPointPath),
+			module.name
+		);
+		fs.mkdirSync(path.dirname(modulePath), { recursive: true });
+		fs.writeFileSync(modulePath, module.content);
+	}
+
 	return {
-		modules: moduleCollector.modules,
+		modules,
 		dependencies,
-		resolvedEntryPointPath: path.resolve(
-			entry.directory,
-			entryPointOutputs[0][0]
-		),
+		resolvedEntryPointPath,
 		bundleType,
 		stop: result.stop,
 		sourceMapPath,
+		sourceMapMetadata: {
+			tmpDir: tmpDir.path,
+			entryDirectory: entry.directory,
+		},
 	};
 }
 
@@ -433,14 +569,16 @@ interface MiddlewareLoader {
 async function applyMiddlewareLoaderFacade(
 	entry: Entry,
 	tmpDirPath: string,
-	middleware: MiddlewareLoader[], // a list of paths to middleware files
-	moduleCollectorPlugin: esbuild.Plugin
-): Promise<Entry> {
+	middleware: MiddlewareLoader[] // a list of paths to middleware files
+): Promise<EntryWithInject> {
 	// Firstly we need to insert the middleware array into the project,
 	// and then we load the middleware - this insertion and loading is
 	// different for each format.
 
-	// STEP 1: Insert the middleware
+	// Make sure we resolve all files relative to the actual temporary directory,
+	// otherwise we'll have issues with source maps
+	tmpDirPath = fs.realpathSync(tmpDirPath);
+
 	const targetPathInsertion = path.join(
 		tmpDirPath,
 		"middleware-insertion.entry.js"
@@ -483,7 +621,7 @@ async function applyMiddlewareLoaderFacade(
 		);
 
 		await esbuild.build({
-			entryPoints: [path.resolve(getBasePath(), dynamicFacadePath)],
+			entryPoints: [dynamicFacadePath],
 			bundle: true,
 			sourcemap: true,
 			format: "esm",
@@ -493,105 +631,88 @@ async function applyMiddlewareLoaderFacade(
 					...Object.fromEntries(
 						middleware.map((val, index) => [
 							middlewareIdentifiers[index],
-							toUrlPath(path.resolve(getBasePath(), val.path)),
+							path.resolve(getBasePath(), val.path),
 						])
 					),
 				}),
 			],
 			outfile: targetPathInsertion,
 		});
-	} else {
-		// We handle service workers slightly differently as we have to overwrite
-		// the event listeners and reimplement them
-
+		const targetPathLoader = path.join(
+			tmpDirPath,
+			"middleware-loader.entry.js"
+		);
+		const loaderPath = path.resolve(
+			getBasePath(),
+			"templates/middleware/loader-modules.ts"
+		);
 		await esbuild.build({
-			entryPoints: [entry.file],
+			entryPoints: [loaderPath],
 			bundle: true,
 			sourcemap: true,
-			define: {
-				"process.env.NODE_ENV": `"${process.env["NODE_ENV" + ""]}"`,
-			},
 			format: "esm",
-			outfile: targetPathInsertion,
-			plugins: [moduleCollectorPlugin],
+			plugins: [
+				esbuildAliasExternalPlugin({
+					__ENTRY_POINT__: targetPathInsertion,
+					"./common": path.resolve(
+						getBasePath(),
+						"templates/middleware/common.ts"
+					),
+				}),
+			],
+			outfile: targetPathLoader,
 		});
-
+		return {
+			...entry,
+			file: targetPathLoader,
+		};
+	} else {
 		const imports = middlewareIdentifiers
-			.map(
-				(m, i) =>
-					`import ${m} from "${toUrlPath(
-						path.resolve(getBasePath(), middleware[i].path)
-					)}";`
-			)
+			.map((m) => `import ${m} from "${m}";`)
 			.join("\n");
-
-		// We add the new modules with imports and then register using the
-		// addMiddleware function (which gets rewritten in the next build step)
-
-		// We choose to run middleware inserted in wrangler before user inserted
-		// middleware in the stack
-		// To do this, we either need to execute the addMiddleware function first
-		// before any user middleware, or use a separate handling function.
-		// We choose to do the latter as to prepend, we would have to load the entire
-		// script into memory as a prepend function doesn't exist or work in the same
-		// way that an append function does.
-
-		fs.copyFileSync(targetPathInsertion, dynamicFacadePath);
-		fs.appendFileSync(
-			dynamicFacadePath,
-			`
+		const contents = `import { __facade_registerInternal__ } from "__LOADER__";
 			${imports}
-			addMiddlewareInternal([${middlewareIdentifiers.join(",")}])
-		`
-		);
-	}
+			__facade_registerInternal__([${middlewareIdentifiers.join(",")}]);`;
+		fs.writeFileSync(dynamicFacadePath, contents);
 
-	// STEP 2: Load the middleware
-	// We want to get the filename of the orginal entry point
-	let targetPathLoader = path.join(tmpDirPath, path.basename(entry.file));
-	if (path.extname(entry.file) === "") targetPathLoader += ".js";
-
-	const loaderPath =
-		entry.format === "modules"
-			? path.resolve(getBasePath(), "templates/middleware/loader-modules.ts")
-			: dynamicFacadePath;
-
-	await esbuild.build({
-		entryPoints: [loaderPath],
-		bundle: true,
-		sourcemap: true,
-		format: "esm",
-		...(entry.format === "service-worker"
-			? {
-					inject: [
-						path.resolve(getBasePath(), "templates/middleware/loader-sw.ts"),
-					],
-					define: {
-						addEventListener: "__facade_addEventListener__",
-						removeEventListener: "__facade_removeEventListener__",
-						dispatchEvent: "__facade_dispatchEvent__",
-						addMiddleware: "__facade_register__",
-						addMiddlewareInternal: "__facade_registerInternal__",
-					},
-			  }
-			: {
-					plugins: [
-						esbuildAliasExternalPlugin({
-							__ENTRY_POINT__: targetPathInsertion,
-							"./common": path.resolve(
+		await esbuild.build({
+			entryPoints: [dynamicFacadePath],
+			bundle: true,
+			sourcemap: true,
+			format: "iife",
+			plugins: [
+				{
+					name: "dynamic-facade-imports",
+					setup(build) {
+						build.onResolve({ filter: /^__LOADER__$/ }, () => {
+							const loaderPath = path.resolve(
 								getBasePath(),
-								"templates/middleware/common.ts"
-							),
-						}),
-					],
-			  }),
-		outfile: targetPathLoader,
-	});
-
-	return {
-		...entry,
-		file: targetPathLoader,
-	};
+								"templates/middleware/loader-sw.ts"
+							);
+							return { path: loaderPath };
+						});
+						const middlewareFilter = /^__MIDDLEWARE_(\d+)__$/;
+						build.onResolve({ filter: middlewareFilter }, (args) => {
+							const match = middlewareFilter.exec(args.path);
+							assert(match !== null);
+							const middlewareIndex = parseInt(match[1]);
+							return {
+								path: path.resolve(
+									getBasePath(),
+									middleware[middlewareIndex].path
+								),
+							};
+						});
+					},
+				},
+			],
+			outfile: targetPathInsertion,
+		});
+		return {
+			...entry,
+			inject: [targetPathInsertion],
+		};
+	}
 }
 
 /**
@@ -741,17 +862,51 @@ async function applyFirstPartyWorkerDevFacade(
  * This code be removed from here when the API is in Workers core,
  * but moved inside Miniflare for simulating D1.
  */
-
 async function applyD1BetaFacade(
 	entry: Entry,
 	tmpDirPath: string,
 	betaD1Shims: string[],
-	local: boolean
+	miniflare2: boolean,
+	doBindings: DurableObjectBindings
 ): Promise<Entry> {
+	let entrypointPath = path.resolve(
+		getBasePath(),
+		"templates/d1-beta-facade.js"
+	);
+	if (Array.isArray(doBindings) && doBindings.length > 0) {
+		//we have DO bindings, so we need to shim them
+		const maskedDoBindings = doBindings
+			// Don't shim anything not local to this worker
+			.filter((b) => !b.script_name)
+			// Reexport the DO classnames
+			.map(
+				(b) =>
+					`export const ${b.class_name} = maskDurableObjectDefinition(OTHER_EXPORTS.${b.class_name});`
+			)
+			.join("\n");
+		const baseFile = fs.readFileSync(
+			path.resolve(getBasePath(), "templates/d1-beta-facade.js"),
+			"utf8"
+		);
+		//getMaskedEnv is already used to shim regular Workers
+		const contents = `
+		${baseFile}
+
+		var maskDurableObjectDefinition = (cls) =>
+		class extends cls {
+			constructor(state, env) {
+				super(state, getMaskedEnv(env));
+			}
+		};
+		${maskedDoBindings}`;
+		const doD1FacadePath = path.join(tmpDirPath, "d1-do-facade.js");
+		//write our shim so we can build it
+		fs.writeFileSync(doD1FacadePath, contents);
+		entrypointPath = doD1FacadePath;
+	}
 	const targetPath = path.join(tmpDirPath, "d1-beta-facade.entry.js");
-
 	await esbuild.build({
-		entryPoints: [path.resolve(getBasePath(), "templates/d1-beta-facade.js")],
+		entryPoints: [entrypointPath],
 		bundle: true,
 		format: "esm",
 		sourcemap: true,
@@ -762,7 +917,7 @@ async function applyD1BetaFacade(
 		],
 		define: {
 			__D1_IMPORTS__: JSON.stringify(betaD1Shims),
-			__LOCAL_MODE__: JSON.stringify(local),
+			__LOCAL_MODE__: JSON.stringify(miniflare2),
 		},
 		outfile: targetPath,
 	});
@@ -782,4 +937,16 @@ function listEntryPoints(
 	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
 }
 
+/**
+ * Prefer modules towards the end of the array in the case of a collision by name.
+ */
+export function dedupeModulesByName(modules: CfModule[]): CfModule[] {
+	return Object.values(
+		modules.reduce((moduleMap, module) => {
+			moduleMap[module.name] = module;
+			return moduleMap;
+		}, {} as Record<string, CfModule>)
+	);
+}
+
 type ValueOf<T> = T[keyof T];

package/src/cfetch/index.ts

@@ -6,8 +6,6 @@ import type { RequestInit } from "undici";
 
 // Check out https://api.cloudflare.com/ for API docs.
 
-export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
-
 export interface FetchError {
 	code: number;
 	message: string;