wrangler 2.3.2 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.3.2",
+	"version": "2.4.1",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -119,7 +119,7 @@
 		"@databases/sql": "^3.2.0",
 		"@iarna/toml": "^3.0.0",
 		"@microsoft/api-extractor": "^7.28.3",
-		"@miniflare/tre": "^3.0.0-next.5",
+		"@miniflare/tre": "^3.0.0-next.7",
 		"@types/better-sqlite3": "^7.6.0",
 		"@types/busboy": "^1.5.0",
 		"@types/command-exists": "^1.2.0",

package/src/__tests__/dev.test.tsx

@@ -830,6 +830,31 @@ describe("wrangler dev", () => {
 	});
 
 	describe("inspector port", () => {
+		it("should connect WebSocket server with --experimental-local", async () => {
+			writeWranglerToml({
+				main: "./index.js",
+			});
+			fs.writeFileSync(
+				"index.js",
+				`export default {
+					async fetch(request, env, ctx ){
+						console.log('Hello World LOGGING');
+					},
+			};`
+			);
+			await runWrangler("dev --experimental-local");
+
+			expect((Dev as jest.Mock).mock.calls[0][0].inspectorPort).toEqual(9229);
+			expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "",
+			  "warn": "",
+			}
+		`);
+		});
+
 		it("should use 9229 as the default port", async () => {
 			writeWranglerToml({
 				main: "index.js",
@@ -1178,10 +1203,12 @@ describe("wrangler dev", () => {
 			      --tsconfig                                   Path to a custom tsconfig.json file  [string]
 			  -l, --local                                      Run on my machine  [boolean] [default: false]
 			      --experimental-local                         Run on my machine using the Cloudflare Workers runtime  [boolean] [default: false]
+			      --experimental-local-remote-kv               Read/write KV data from/to real namespaces on the Cloudflare network  [boolean] [default: false]
 			      --minify                                     Minify the script  [boolean]
 			      --node-compat                                Enable node.js compatibility  [boolean]
 			      --persist                                    Enable persistence for local mode, using default path: .wrangler/state  [boolean]
 			      --persist-to                                 Specify directory to use for local persistence (implies --persist)  [string]
+			      --live-reload                                Auto reload HTML pages when change is detected in local mode  [boolean]
 			      --test-scheduled                             Test scheduled events by visiting /__scheduled in browser  [boolean] [default: false]
 			      --log-level                                  Specify logging level  [choices: \\"debug\\", \\"info\\", \\"log\\", \\"warn\\", \\"error\\", \\"none\\"] [default: \\"log\\"]",
 			  "warn": "",

package/src/__tests__/index.test.ts

@@ -51,6 +51,7 @@ describe("wrangler", () => {
 			  wrangler logout              🚪 Logout from Cloudflare
 			  wrangler whoami              🕵️  Retrieve your user info and test your auth config
 			  wrangler types               📝 Generate types from bindings & module rules in config
+			  wrangler deployments         🚢 Displays the 10 most recent deployments for a worker
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -96,6 +97,7 @@ describe("wrangler", () => {
 			  wrangler logout              🚪 Logout from Cloudflare
 			  wrangler whoami              🕵️  Retrieve your user info and test your auth config
 			  wrangler types               📝 Generate types from bindings & module rules in config
+			  wrangler deployments         🚢 Displays the 10 most recent deployments for a worker
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]

package/src/__tests__/metrics.test.ts

@@ -364,7 +364,7 @@ describe("metrics", () => {
 
 				expect(std.out).toMatchInlineSnapshot(`
 			"Usage metrics tracking has changed since you last granted permission.
-			Your choice has been saved in the following file: home/.wrangler/config/metrics.json.
+			Your choice has been saved in the following file: test-xdg-config/metrics.json.
 
 			  You can override the user level setting for a project in \`wrangler.toml\`:
 

package/src/__tests__/pages.test.ts

@@ -1165,16 +1165,21 @@ describe("pages", () => {
 						const body = init.body as FormData;
 						const manifest = JSON.parse(body.get("manifest") as string);
 
-						// for Functions projects, we auto-generate a `_worker.js` and `_routes.json`
+						// for Functions projects, we auto-generate a `_worker.js`,
+						// `functions-filepath-routing-config.json`, and `_routes.json`
 						// file, based on the contents of `/functions`
 						const generatedWorkerJS = body.get("_worker.js") as Blob;
 						const generatedRoutesJSON = await (
 							body.get("_routes.json") as Blob
 						).text();
+						const generatedFilepathRoutingConfig = await (
+							body.get("functions-filepath-routing-config.json") as Blob
+						).text();
 
 						// make sure this is all we uploaded
 						expect([...body.keys()]).toEqual([
 							"manifest",
+							"functions-filepath-routing-config.json",
 							"_worker.js",
 							"_routes.json",
 						]);
@@ -1202,6 +1207,25 @@ describe("pages", () => {
 							include: ["/hello"],
 							exclude: [],
 						});
+
+						// Make sure the routing config is valid json
+						const parsedFilepathRoutingConfig = JSON.parse(
+							generatedFilepathRoutingConfig
+						);
+						// The actual shape doesn't matter that much since this
+						// is only used for display in Dash, but it's still useful for
+						// tracking unexpected changes to this config.
+						expect(parsedFilepathRoutingConfig).toStrictEqual({
+							routes: [
+								{
+									routePath: "/hello",
+									mountPath: "/",
+									method: "",
+									module: ["hello.js:onRequest"],
+								},
+							],
+							baseURL: "/",
+						});
 					});
 
 					return {
@@ -1456,10 +1480,14 @@ describe("pages", () => {
 						const customRoutesJSON = await (
 							body.get("_routes.json") as Blob
 						).text();
+						const generatedFilepathRoutingConfig = await (
+							body.get("functions-filepath-routing-config.json") as Blob
+						).text();
 
 						// make sure this is all we uploaded
 						expect([...body.keys()]).toEqual([
 							"manifest",
+							"functions-filepath-routing-config.json",
 							"_worker.js",
 							"_routes.json",
 						]);
@@ -1481,6 +1509,32 @@ describe("pages", () => {
 							include: ["/hello"],
 							exclude: [],
 						});
+
+						// Make sure the routing config is valid json
+						const parsedFilepathRoutingConfig = JSON.parse(
+							generatedFilepathRoutingConfig
+						);
+						// The actual shape doesn't matter that much since this
+						// is only used for display in Dash, but it's still useful for
+						// tracking unexpected changes to this config.
+						console.log(generatedFilepathRoutingConfig);
+						expect(parsedFilepathRoutingConfig).toStrictEqual({
+							routes: [
+								{
+									routePath: "/goodbye",
+									mountPath: "/",
+									method: "",
+									module: ["goodbye.ts:onRequest"],
+								},
+								{
+									routePath: "/hello",
+									mountPath: "/",
+									method: "",
+									module: ["hello.js:onRequest"],
+								},
+							],
+							baseURL: "/",
+						});
 					});
 
 					return {

package/src/api/dev.ts

@@ -56,6 +56,8 @@ interface DevOptions {
 	$0?: string; //yargs wants this
 	testScheduled?: boolean;
 	experimentalLocal?: boolean;
+	accountId?: string;
+	experimentalLocalRemoteKv?: boolean;
 }
 
 interface DevApiOptions {

package/src/bundle.ts

@@ -97,7 +97,6 @@ export async function bundleWorker(
 		targetConsumer: "dev" | "publish";
 		local: boolean;
 		testScheduled?: boolean;
-		experimentalLocalStubCache?: boolean;
 		inject?: string[];
 		loader?: Record<string, string>;
 		sourcemap?: esbuild.CommonOptions["sourcemap"];
@@ -125,7 +124,6 @@ export async function bundleWorker(
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
-		experimentalLocalStubCache,
 		inject: injectOption,
 		loader,
 		sourcemap,
@@ -277,11 +275,6 @@ export async function bundleWorker(
 
 	const inject: string[] = injectOption ?? [];
 	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],

package/src/dev/dev.tsx

@@ -155,6 +155,7 @@ export type DevProps = {
 	sendMetrics: boolean | undefined;
 	testScheduled: boolean | undefined;
 	experimentalLocal: boolean | undefined;
+	experimentalLocalRemoteKv: boolean | undefined;
 };
 
 export function DevImplementation(props: DevProps): JSX.Element {
@@ -287,7 +288,6 @@ function DevSession(props: DevSessionProps) {
 		// Enable the bundling to know whether we are using dev or publish
 		targetConsumer: "dev",
 		testScheduled: props.testScheduled ?? false,
-		experimentalLocalStubCache: props.local && props.experimentalLocal,
 	});
 
 	// TODO(queues) support remote wrangler dev
@@ -326,6 +326,8 @@ function DevSession(props: DevSessionProps) {
 			onReady={props.onReady}
 			enablePagesAssetsServiceBinding={props.enablePagesAssetsServiceBinding}
 			experimentalLocal={props.experimentalLocal}
+			accountId={props.accountId}
+			experimentalLocalRemoteKv={props.experimentalLocalRemoteKv}
 		/>
 	) : (
 		<Remote

package/src/dev/local.tsx

@@ -4,10 +4,10 @@ import { realpathSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import chalk from "chalk";
-import getPort from "get-port";
 import { npxImport } from "npx-import";
 import { useState, useEffect, useRef } from "react";
 import onExit from "signal-exit";
+import { performApiFetch } from "../cfetch/internal";
 import { registerWorker } from "../dev-registry";
 import useInspector from "../inspect";
 import { logger } from "../logger";
@@ -17,8 +17,10 @@ import {
 } from "../module-collection";
 import { getBasePath } from "../paths";
 import { waitForPortToBeAvailable } from "../proxy";
+import { requireAuth } from "../user";
 import type { Config } from "../config";
 import type { WorkerRegistry } from "../dev-registry";
+import type { LoggerLevel } from "../logger";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { AssetPaths } from "../sites";
 import type {
@@ -38,9 +40,12 @@ import type { EsbuildBundle } from "./use-esbuild";
 import type {
 	Miniflare as Miniflare3Type,
 	MiniflareOptions as Miniflare3Options,
+	Log as Miniflare3LogType,
+	CloudflareFetch,
 } from "@miniflare/tre";
 import type { MiniflareOptions } from "miniflare";
 import type { ChildProcess } from "node:child_process";
+import type { RequestInit } from "undici";
 
 export interface LocalProps {
 	name: string | undefined;
@@ -67,15 +72,29 @@ export interface LocalProps {
 	logPrefix?: string;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
 	testScheduled?: boolean;
-	experimentalLocal?: boolean;
+	experimentalLocal: boolean | undefined;
+	accountId: string | undefined; // Account ID? In local mode??? :exploding_head:
+	experimentalLocalRemoteKv: boolean | undefined;
 }
 
+type InspectorJSON = {
+	id: string;
+	title: string;
+	type: "node";
+	description: string;
+	webSocketDebuggerUrl: string;
+	devtoolsFrontendUrl: string;
+	devtoolsFrontendUrlCompat: string;
+	faviconUrl: string;
+	url: string;
+}[];
+
 export function Local(props: LocalProps) {
 	const { inspectorUrl } = useLocalWorker(props);
 	useInspector({
 		inspectorUrl,
 		port: props.inspectorPort,
-		logToTerminal: false,
+		logToTerminal: props.experimentalLocal ?? false,
 	});
 	return null;
 }
@@ -105,6 +124,8 @@ function useLocalWorker({
 	logPrefix,
 	enablePagesAssetsServiceBinding,
 	experimentalLocal,
+	accountId,
+	experimentalLocalRemoteKv,
 }: LocalProps) {
 	// TODO: pass vars via command line
 	const local = useRef<ChildProcess>();
@@ -209,11 +230,24 @@ function useLocalWorker({
 			});
 
 			if (experimentalLocal) {
-				const mf3Options = await transformLocalOptions(options, format, bundle);
+				const log = await buildMiniflare3Logger(logPrefix);
+				const mf3Options = await transformMf2OptionsToMf3Options({
+					miniflare2Options: options,
+					format,
+					bundle,
+					log,
+					kvNamespaces: bindings?.kv_namespaces,
+					r2Buckets: bindings?.r2_buckets,
+					authenticatedAccountId: accountId,
+					kvRemote: experimentalLocalRemoteKv,
+					inspectorPort,
+				});
+
 				const current = experimentalLocalRef.current;
+
 				if (current === undefined) {
 					// If we don't have an active Miniflare instance, create a new one
-					const Miniflare = await getMiniflare3Constructor();
+					const { Miniflare } = await getMiniflare3();
 					if (abortController.signal.aborted) return;
 					const mf = new Miniflare(mf3Options);
 					experimentalLocalRef.current = mf;
@@ -230,6 +264,34 @@ function useLocalWorker({
 					logger.log("⎔ Reloading experimental local server.");
 					await current.setOptions(mf3Options);
 				}
+
+				try {
+					// fetch the inspector JSON response from the DevTools Inspector protocol
+					const inspectorJSONArr = (await (
+						await fetch(`http://127.0.0.1:${inspectorPort}/json`)
+					).json()) as InspectorJSON;
+
+					const foundInspectorURL = inspectorJSONArr?.find((inspectorJSON) =>
+						inspectorJSON.id.startsWith("core:user")
+					)?.webSocketDebuggerUrl;
+					if (foundInspectorURL === undefined) {
+						setInspectorUrl(undefined);
+					} else {
+						const url = new URL(foundInspectorURL);
+						// Force inspector URL to be different on each reload so `useEffect`
+						// in `useInspector` is re-run to connect to newly restarted
+						// `workerd` server when updating options. Can't use a query param
+						// here as that seems to cause an infinite connection loop, can't
+						// use a hash as those are forbidden by `ws`, so username it is.
+						url.username = `${Date.now()}-${Math.floor(
+							Math.random() * Number.MAX_SAFE_INTEGER
+						)}`;
+						setInspectorUrl(url.toString());
+					}
+				} catch (error: unknown) {
+					logger.error("Error attempting to retrieve Debugger URL:", error);
+				}
+
 				return;
 			}
 
@@ -367,6 +429,8 @@ function useLocalWorker({
 		onReady,
 		enablePagesAssetsServiceBinding,
 		experimentalLocal,
+		accountId,
+		experimentalLocalRemoteKv,
 	]);
 
 	// Rather than disposing the Miniflare instance on every reload, only dispose
@@ -683,24 +747,86 @@ export function setupNodeOptions({
 	return nodeOptions;
 }
 
-function arrayToObject(values: string[] = []): Record<string, string> {
-	return Object.fromEntries(values.map((value) => [value, value]));
+export interface SetupMiniflare3Options {
+	// Regular Miniflare 2 options to transform
+	miniflare2Options: MiniflareOptions;
+	// Miniflare 3 requires all modules to be manually specified
+	format: CfScriptFormat;
+	bundle: EsbuildBundle;
+
+	// Miniflare's logger
+	log: Miniflare3LogType;
+
+	// Miniflare 3 accepts namespace/bucket names in addition to binding names.
+	// This means multiple workers persisting to the same location can have
+	// different binding names for the same namespace/bucket. Therefore, we need
+	// the full KV/R2 arrays. This is also required for remote KV storage, as
+	// we need actual namespace IDs to connect to.
+	kvNamespaces: CfKvNamespace[] | undefined;
+	r2Buckets: CfR2Bucket[] | undefined;
+
+	// Account ID to use for authenticated Cloudflare fetch. If true, prompt
+	// user for ID if multiple available.
+	authenticatedAccountId: string | true | undefined;
+	// Whether to read/write from/to real KV namespaces
+	kvRemote: boolean | undefined;
+
+	// Port to start DevTools inspector server on
+	inspectorPort: number;
+}
+
+export async function buildMiniflare3Logger(
+	logPrefix?: string
+): Promise<Miniflare3LogType> {
+	const { Log, NoOpLog, LogLevel } = await getMiniflare3();
+
+	let level = logger.loggerLevel.toUpperCase() as Uppercase<LoggerLevel>;
+	if (level === "LOG") level = "INFO";
+	const logLevel = LogLevel[level];
+
+	return logLevel === LogLevel.NONE
+		? new NoOpLog()
+		: new Log(logLevel, { prefix: logPrefix });
 }
 
-export async function transformLocalOptions(
-	mf2Options: MiniflareOptions,
-	format: CfScriptFormat,
-	bundle: EsbuildBundle
-): Promise<Miniflare3Options> {
+export async function transformMf2OptionsToMf3Options({
+	miniflare2Options,
+	format,
+	bundle,
+	log,
+	kvNamespaces,
+	r2Buckets,
+	authenticatedAccountId,
+	kvRemote,
+	inspectorPort,
+}: SetupMiniflare3Options): Promise<Miniflare3Options> {
+	// Build authenticated Cloudflare API fetch function if required
+	let cloudflareFetch: CloudflareFetch | undefined;
+	if (kvRemote && authenticatedAccountId !== undefined) {
+		const preferredAccountId =
+			authenticatedAccountId === true ? undefined : authenticatedAccountId;
+		const accountId = await requireAuth({ account_id: preferredAccountId });
+		cloudflareFetch = (resource, searchParams, init) => {
+			resource = `/accounts/${accountId}/${resource}`;
+			// Miniflare and Wrangler's `undici` versions may be slightly different,
+			// but their `RequestInit` types *should* be compatible
+			return performApiFetch(resource, init as RequestInit, searchParams);
+		};
+	}
+
 	const options: Miniflare3Options = {
-		...mf2Options,
+		...miniflare2Options,
 		// Miniflare 3 distinguishes between binding name and namespace/bucket IDs.
-		// For now, just use the same value as we did in Miniflare 2.
-		// TODO: use defined KV preview ID if any
-		kvNamespaces: arrayToObject(mf2Options.kvNamespaces),
-		r2Buckets: arrayToObject(mf2Options.r2Buckets),
-		inspectorPort: await getPort({ port: 9229 }),
+		kvNamespaces: Object.fromEntries(
+			kvNamespaces?.map(({ binding, id }) => [binding, id]) ?? []
+		),
+		r2Buckets: Object.fromEntries(
+			r2Buckets?.map(({ binding, bucket_name }) => [binding, bucket_name]) ?? []
+		),
+		inspectorPort,
 		verbose: true,
+		cloudflareFetch,
+		log,
 	};
 
 	if (format === "modules") {
@@ -729,18 +855,30 @@ export async function transformLocalOptions(
 		];
 	}
 
+	if (kvRemote) {
+		// `kvPersist` is always assigned a truthy value in `setupMiniflareOptions`
+		assert(options.kvPersist);
+		const kvRemoteCache =
+			options.kvPersist === true
+				? // If storing in temporary directory, find this path from the bundle
+				  // output path
+				  path.join(path.dirname(bundle.path), ".mf", "kv-remote")
+				: // Otherwise, `kvPersist` looks like `.../kv`, so rewrite it to
+				  // `kv-remote` since the expected metadata format for remote storage
+				  // is different to local
+				  path.join(path.dirname(options.kvPersist), "kv-remote");
+		options.kvPersist = `remote:?cache=${encodeURIComponent(kvRemoteCache)}`;
+	}
+
 	return options;
 }
 
 // Caching of the `npx-import`ed `@miniflare/tre` package
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-let Miniflare: typeof import("@miniflare/tre").Miniflare;
-export async function getMiniflare3Constructor(): Promise<typeof Miniflare> {
-	if (Miniflare === undefined) {
-		({ Miniflare } = await npxImport<
-			// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-			typeof import("@miniflare/tre")
-		>("@miniflare/tre@3.0.0-next.5"));
-	}
-	return Miniflare;
+let miniflare3Module: typeof import("@miniflare/tre");
+export async function getMiniflare3(): Promise<
+	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+	typeof import("@miniflare/tre")
+> {
+	return (miniflare3Module ??= await npxImport("@miniflare/tre@3.0.0-next.7"));
 }

package/src/dev/start-server.ts

@@ -17,10 +17,11 @@ import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
 import {
 	setupBindings,
-	getMiniflare3Constructor,
+	getMiniflare3,
+	buildMiniflare3Logger,
 	setupMiniflareOptions,
 	setupNodeOptions,
-	transformLocalOptions,
+	transformMf2OptionsToMf3Options,
 } from "./local";
 import { startRemoteServer } from "./remote";
 import { validateDevProps } from "./validate-dev-props";
@@ -98,7 +99,6 @@ export async function startDevServer(
 			services: props.bindings.services,
 			firstPartyWorkerDevFacade: props.firstPartyWorker,
 			testScheduled: props.testScheduled,
-			experimentalLocalStubCache: props.experimentalLocal,
 		});
 
 		if (props.local) {
@@ -127,6 +127,8 @@ export async function startDevServer(
 				usageModel: props.usageModel,
 				workerDefinitions,
 				experimentalLocal: props.experimentalLocal,
+				accountId: props.accountId,
+				experimentalLocalRemoteKv: props.experimentalLocalRemoteKv,
 			});
 
 			return {
@@ -204,7 +206,6 @@ async function runEsbuild({
 	services,
 	firstPartyWorkerDevFacade,
 	testScheduled,
-	experimentalLocalStubCache,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -223,7 +224,6 @@ async function runEsbuild({
 	workerDefinitions: WorkerRegistry;
 	firstPartyWorkerDevFacade: boolean | undefined;
 	testScheduled?: boolean;
-	experimentalLocalStubCache: boolean | undefined;
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
@@ -264,7 +264,6 @@ async function runEsbuild({
 				targetConsumer: "dev", // We are starting a dev server
 				local: true,
 				testScheduled,
-				experimentalLocalStubCache,
 		  });
 
 	return {
@@ -303,6 +302,8 @@ export async function startLocalServer({
 	logPrefix,
 	enablePagesAssetsServiceBinding,
 	experimentalLocal,
+	accountId,
+	experimentalLocalRemoteKv,
 }: LocalProps) {
 	let local: ChildProcess | undefined;
 	let experimentalLocalRef: Miniflare3Type | undefined;
@@ -396,8 +397,19 @@ export async function startLocalServer({
 		});
 
 		if (experimentalLocal) {
-			const mf3Options = await transformLocalOptions(options, format, bundle);
-			const Miniflare = await getMiniflare3Constructor();
+			const log = await buildMiniflare3Logger(logPrefix);
+			const mf3Options = await transformMf2OptionsToMf3Options({
+				miniflare2Options: options,
+				format,
+				bundle,
+				log,
+				kvNamespaces: bindings?.kv_namespaces,
+				r2Buckets: bindings?.r2_buckets,
+				authenticatedAccountId: accountId,
+				kvRemote: experimentalLocalRemoteKv,
+				inspectorPort,
+			});
+			const { Miniflare } = await getMiniflare3();
 			const mf = new Miniflare(mf3Options);
 			const runtimeURL = await mf.ready;
 			experimentalLocalRef = mf;

package/src/dev/use-esbuild.ts

@@ -41,7 +41,6 @@ export function useEsbuild({
 	local,
 	targetConsumer,
 	testScheduled,
-	experimentalLocalStubCache,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -63,7 +62,6 @@ export function useEsbuild({
 	local: boolean;
 	targetConsumer: "dev" | "publish";
 	testScheduled: boolean;
-	experimentalLocalStubCache: boolean | undefined;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -136,7 +134,6 @@ export function useEsbuild({
 						local,
 						targetConsumer,
 						testScheduled,
-						experimentalLocalStubCache,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -198,7 +195,6 @@ export function useEsbuild({
 		local,
 		targetConsumer,
 		testScheduled,
-		experimentalLocalStubCache,
 	]);
 	return bundle;
 }