wrangler 0.0.0-e30d1013 → 0.0.0-e311bbbf

package/src/bundle.ts

@@ -9,10 +9,17 @@ import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
 import { getBasePath, toUrlPath } 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 { CfModule } from "./worker";
 
+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"];
@@ -28,6 +35,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,
@@ -72,6 +92,24 @@ Add "node_compat = true" to your wrangler.toml file to enable Node compatibility
 	}
 }
 
+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.
  */
@@ -82,13 +120,16 @@ export async function bundleWorker(
 		serveAssetsFromWorker: boolean;
 		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
+		doBindings: DurableObjectBindings;
 		jsxFactory?: string;
 		jsxFragment?: string;
+		entryName?: string;
 		rules: Config["rules"];
 		watch?: esbuild.WatchMode | boolean;
 		tsconfig?: string;
 		minify?: boolean;
-		nodeCompat?: boolean;
+		legacyNodeCompat?: boolean;
+		nodejsCompat?: boolean;
 		define: Config["define"];
 		checkFetch: boolean;
 		services?: Config["services"];
@@ -97,12 +138,12 @@ export async function bundleWorker(
 		targetConsumer: "dev" | "publish";
 		local: boolean;
 		testScheduled?: boolean;
-		experimentalLocalStubCache?: boolean;
+		experimentalLocal?: boolean;
 		inject?: string[];
 		loader?: Record<string, string>;
 		sourcemap?: esbuild.CommonOptions["sourcemap"];
 		plugins?: esbuild.Plugin[];
-		// TODO: Rip these out https://github.com/cloudflare/wrangler2/issues/2153
+		// TODO: Rip these out https://github.com/cloudflare/workers-sdk/issues/2153
 		disableModuleCollection?: boolean;
 		isOutfile?: boolean;
 	}
@@ -110,13 +151,16 @@ export async function bundleWorker(
 	const {
 		serveAssetsFromWorker,
 		betaD1Shims,
+		doBindings,
 		jsxFactory,
 		jsxFragment,
+		entryName,
 		rules,
 		watch,
 		tsconfig,
 		minify,
-		nodeCompat,
+		legacyNodeCompat,
+		nodejsCompat,
 		checkFetch,
 		local,
 		assets,
@@ -125,7 +169,7 @@ export async function bundleWorker(
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
-		experimentalLocalStubCache,
+		experimentalLocal,
 		inject: injectOption,
 		loader,
 		sourcemap,
@@ -199,8 +243,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 &&
@@ -237,7 +302,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
@@ -261,75 +332,67 @@ 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[] = 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],
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
+		entryNames: entryName || path.parse(entry.file).name,
 		...(isOutfile
 			? {
 					outdir: undefined,
 					outfile: destination,
+					entryNames: undefined,
 			  }
 			: {}),
 		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
-		target: "es2020",
+		target: COMMON_ESBUILD_OPTIONS.target,
 		sourcemap: sourcemap ?? true, // this needs to use ?? to accept false
 		// 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 }),
@@ -345,7 +408,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);
 		throw e;
 	}
 
@@ -371,13 +435,23 @@ export async function bundleWorker(
 		_path.includes(".map")
 	)[0];
 
+	const resolvedEntryPointPath = path.resolve(
+		entry.directory,
+		entryPointOutputs[0][0]
+	);
+
+	// copy all referenced modules into the output bundle directory
+	for (const module of moduleCollector.modules) {
+		fs.writeFileSync(
+			path.join(path.dirname(resolvedEntryPointPath), module.name),
+			module.content
+		);
+	}
+
 	return {
 		modules: moduleCollector.modules,
 		dependencies,
-		resolvedEntryPointPath: path.resolve(
-			entry.directory,
-			entryPointOutputs[0][0]
-		),
+		resolvedEntryPointPath,
 		bundleType,
 		stop: result.stop,
 		sourceMapPath,
@@ -463,14 +537,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"
@@ -513,7 +589,7 @@ async function applyMiddlewareLoaderFacade(
 		);
 
 		await esbuild.build({
-			entryPoints: [path.resolve(getBasePath(), dynamicFacadePath)],
+			entryPoints: [dynamicFacadePath],
 			bundle: true,
 			sourcemap: true,
 			format: "esm",
@@ -530,98 +606,81 @@ async function applyMiddlewareLoaderFacade(
 			],
 			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],
+		};
+	}
 }
 
 /**
@@ -771,17 +830,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,
@@ -792,7 +885,7 @@ async function applyD1BetaFacade(
 		],
 		define: {
 			__D1_IMPORTS__: JSON.stringify(betaD1Shims),
-			__LOCAL_MODE__: JSON.stringify(local),
+			__LOCAL_MODE__: JSON.stringify(miniflare2),
 		},
 		outfile: targetPath,
 	});

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;

package/src/cfetch/internal.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { fetch, File, Headers } from "undici";
 import { version as wranglerVersion } from "../../package.json";
-import { getEnvironmentVariableFactory } from "../environment-variables";
+import { getCloudflareApiBaseUrl } from "../environment-variables/misc-variables";
 import { logger } from "../logger";
 import { ParseError, parseJSON } from "../parse";
 import { loginOrRefreshIfRequired, requireApiToken } from "../user";
@@ -9,15 +9,6 @@ import type { ApiCredentials } from "../user";
 import type { URLSearchParams } from "node:url";
 import type { RequestInit, HeadersInit, Response } from "undici";
 
-/**
- * Get the URL to use to access the Cloudflare API.
- */
-export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
-	variableName: "CLOUDFLARE_API_BASE_URL",
-	deprecatedName: "CF_API_BASE_URL",
-	defaultValue: "https://api.cloudflare.com/client/v4",
-});
-
 /*
  * performApiFetch does everything required to make a CF API request,
  * but doesn't parse the response as JSON. For normal V4 API responses,
@@ -42,12 +33,17 @@ export async function performApiFetch(
 
 	const queryString = queryParams ? `?${queryParams.toString()}` : "";
 	logger.debug(
-		`-- START CF API REQUEST: ${method} ${getCloudflareAPIBaseURL()}${resource}${queryString}`
+		`-- START CF API REQUEST: ${method} ${getCloudflareApiBaseUrl()}${resource}${queryString}`
+	);
+	const logHeaders = cloneHeaders(headers);
+	delete logHeaders["Authorization"];
+	logger.debug("HEADERS:", JSON.stringify(logHeaders, null, 2));
+	logger.debug(
+		"INIT:",
+		JSON.stringify({ ...init, headers: logHeaders }, null, 2)
 	);
-	logger.debug("HEADERS:", JSON.stringify(headers, null, 2));
-	logger.debug("INIT:", JSON.stringify(init, null, 2));
 	logger.debug("-- END CF API REQUEST");
-	return await fetch(`${getCloudflareAPIBaseURL()}${resource}${queryString}`, {
+	return await fetch(`${getCloudflareApiBaseUrl()}${resource}${queryString}`, {
 		method,
 		...init,
 		headers,
@@ -83,7 +79,9 @@ export async function fetchInternal<ResponseType>(
 		response.statusText,
 		response.status
 	);
-	logger.debug("HEADERS:", JSON.stringify(response.headers, null, 2));
+	const logHeaders = cloneHeaders(response.headers);
+	delete logHeaders["Authorization"];
+	logger.debug("HEADERS:", JSON.stringify(logHeaders, null, 2));
 	logger.debug("RESPONSE:", jsonText);
 	logger.debug("-- END CF API RESPONSE");
 
@@ -166,7 +164,7 @@ export async function fetchKVGetValue(
 	const auth = requireApiToken();
 	const headers: Record<string, string> = {};
 	addAuthorizationHeaderIfUnspecified(headers, auth);
-	const resource = `${getCloudflareAPIBaseURL()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+	const resource = `${getCloudflareApiBaseUrl()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
 	const response = await fetch(resource, {
 		method: "GET",
 		headers,
@@ -199,7 +197,7 @@ export async function fetchR2Objects(
 	addAuthorizationHeaderIfUnspecified(headers, auth);
 	addUserAgent(headers);
 
-	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+	const response = await fetch(`${getCloudflareApiBaseUrl()}${resource}`, {
 		...bodyInit,
 		headers,
 	});
@@ -226,7 +224,7 @@ export async function fetchDashboardScript(
 	addAuthorizationHeaderIfUnspecified(headers, auth);
 	addUserAgent(headers);
 
-	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+	const response = await fetch(`${getCloudflareApiBaseUrl()}${resource}`, {
 		...bodyInit,
 		headers,
 	});
@@ -254,9 +252,6 @@ export async function fetchDashboardScript(
 		}
 
 		return file ?? "";
-
-		// Follow up on issue in Undici about multipart/form-data support & replace the workaround: https://github.com/nodejs/undici/issues/974
-		// This should be using a builtin formData() parser pattern.
 	} else {
 		return response.text();
 	}

package/src/cli.ts

@@ -1,10 +1,10 @@
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { unstable_dev } from "./api";
+import { unstable_dev, unstable_pages } from "./api";
 import { FatalError } from "./errors";
 import { main } from ".";
 
-import type { UnstableDevWorker } from "./api";
+import type { UnstableDevWorker, UnstableDevOptions } from "./api";
 /**
  * The main entrypoint for the CLI.
  * main only gets called when the script is run directly, not when it's imported as a module.
@@ -24,5 +24,5 @@ if (typeof jest === "undefined" && require.main === module) {
  * It makes it possible to import wrangler from 'wrangler',
  * and call wrangler.unstable_dev().
  */
-export { unstable_dev };
-export type { UnstableDevWorker };
+export { unstable_dev, unstable_pages };
+export type { UnstableDevWorker, UnstableDevOptions };