miniflare 0.0.0-e4fe35cc5 → 0.0.0-e747ddf6a

package/dist/src/index.js

@@ -95,11 +95,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path27) {
-      path27 = String(path27);
-      let last = path27.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path28) {
+      path28 = String(path28);
+      let last = path28.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path27.length;
+      let hasPath = last.length < path28.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -2456,7 +2456,6 @@ __export(src_exports, {
   DispatchFetchDispatcher: () => DispatchFetchDispatcher,
   DurableObjectsOptionsSchema: () => DurableObjectsOptionsSchema,
   DurableObjectsSharedOptionsSchema: () => DurableObjectsSharedOptionsSchema,
-  ENTRY_SOCKET_HTTP_OPTIONS: () => ENTRY_SOCKET_HTTP_OPTIONS,
   ErrorEvent: () => ErrorEvent,
   File: () => import_undici4.File,
   FormData: () => import_undici4.FormData,
@@ -2535,10 +2534,15 @@ __export(src_exports, {
   TlsOptions_Version: () => import_workerd_capnp.TlsOptions_Version,
   TypedEventTarget: () => TypedEventTarget,
   WORKER_BINDING_SERVICE_LOOPBACK: () => WORKER_BINDING_SERVICE_LOOPBACK,
+  WORKFLOWS_PLUGIN: () => WORKFLOWS_PLUGIN,
+  WORKFLOWS_PLUGIN_NAME: () => WORKFLOWS_PLUGIN_NAME,
+  WORKFLOWS_STORAGE_SERVICE_NAME: () => WORKFLOWS_STORAGE_SERVICE_NAME,
   WaitGroup: () => WaitGroup,
   WebSocket: () => WebSocket,
   WebSocketPair: () => WebSocketPair,
   Worker_Binding_CryptoKey_Usage: () => import_workerd_capnp.Worker_Binding_CryptoKey_Usage,
+  WorkflowsOptionsSchema: () => WorkflowsOptionsSchema,
+  WorkflowsSharedOptionsSchema: () => WorkflowsSharedOptionsSchema,
   __MiniflareFunctionWrapper: () => __MiniflareFunctionWrapper,
   _enableControlEndpoints: () => _enableControlEndpoints,
   _forceColour: () => _forceColour,
@@ -2547,7 +2551,7 @@ __export(src_exports, {
   _transformsForContentEncodingAndContentType: () => _transformsForContentEncodingAndContentType,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
-  buildAssetsManifest: () => buildAssetsManifest,
+  buildAssetManifest: () => buildAssetManifest,
   compileModuleRules: () => compileModuleRules,
   coupleWebSocket: () => coupleWebSocket,
   createFetchMock: () => createFetchMock,
@@ -2567,6 +2571,7 @@ __export(src_exports, {
   getFreshSourceMapSupport: () => getFreshSourceMapSupport,
   getGlobalServices: () => getGlobalServices,
   getMiniflareObjectBindings: () => getMiniflareObjectBindings,
+  getNodeCompat: () => getNodeCompat,
   getPersistPath: () => getPersistPath,
   getRootPath: () => getRootPath,
   globsToRegExps: () => globsToRegExps,
@@ -2611,11 +2616,11 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_assert12 = __toESM(require("assert"));
 var import_crypto3 = __toESM(require("crypto"));
-var import_fs21 = __toESM(require("fs"));
+var import_fs22 = __toESM(require("fs"));
 var import_http6 = __toESM(require("http"));
 var import_net = __toESM(require("net"));
 var import_os2 = __toESM(require("os"));
-var import_path25 = __toESM(require("path"));
+var import_path26 = __toESM(require("path"));
 var import_web5 = require("stream/web");
 var import_util5 = __toESM(require("util"));
 var import_zlib = __toESM(require("zlib"));
@@ -2702,7 +2707,7 @@ function zod_worker_default() {
 
 // src/index.ts
 var import_ws3 = require("ws");
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/cf.ts
 var import_assert = __toESM(require("assert"));
@@ -3310,12 +3315,12 @@ function createHTTPRevivers(impl) {
     },
     Request(value) {
       (0, import_node_assert.default)(Array.isArray(value));
-      const [method, url17, headers, cf, body] = value;
+      const [method, url18, headers, cf, body] = value;
       (0, import_node_assert.default)(typeof method === "string");
-      (0, import_node_assert.default)(typeof url17 === "string");
+      (0, import_node_assert.default)(typeof url18 === "string");
       (0, import_node_assert.default)(headers instanceof impl.Headers);
       (0, import_node_assert.default)(body === null || impl.isReadableStream(body));
-      return new impl.Request(url17, {
+      return new impl.Request(url18, {
         method,
         headers,
         cf,
@@ -3444,23 +3449,23 @@ function parseWithReadableStreams(impl, stringified, revivers2) {
 }
 
 // src/workers/core/routing.ts
-function matchRoutes(routes, url17) {
+function matchRoutes(routes, url18) {
   for (const route of routes) {
-    if (route.protocol && route.protocol !== url17.protocol)
+    if (route.protocol && route.protocol !== url18.protocol)
       continue;
     if (route.allowHostnamePrefix) {
-      if (!url17.hostname.endsWith(route.hostname))
+      if (!url18.hostname.endsWith(route.hostname))
         continue;
     } else {
-      if (url17.hostname !== route.hostname)
+      if (url18.hostname !== route.hostname)
         continue;
     }
-    const path27 = url17.pathname + url17.search;
+    const path28 = url18.pathname + url18.search;
     if (route.allowPathSuffix) {
-      if (!path27.startsWith(route.path))
+      if (!path28.startsWith(route.path))
         continue;
     } else {
-      if (path27 !== route.path)
+      if (path28 !== route.path)
         continue;
     }
     return route.target;
@@ -3705,8 +3710,8 @@ function decodeSitesKey(key) {
   return key.startsWith(SITES_NO_CACHE_PREFIX) ? decodeURIComponent(key.substring(SITES_NO_CACHE_PREFIX.length)) : key;
 }
 function isSitesRequest(request) {
-  const url17 = new URL(request.url);
-  return url17.pathname.startsWith(`/${SITES_NO_CACHE_PREFIX}`);
+  const url18 = new URL(request.url);
+  return url18.pathname.startsWith(`/${SITES_NO_CACHE_PREFIX}`);
 }
 function serialiseRegExp(regExp) {
   const str = regExp.toString();
@@ -3782,11 +3787,18 @@ var QueueConsumerOptionsSchema = /* @__PURE__ */ import_zod2.z.object({
   // https://developers.cloudflare.com/queues/platform/configuration/#consumer
   // https://developers.cloudflare.com/queues/platform/limits/
   maxBatchSize: import_zod2.z.number().min(0).max(100).optional(),
-  maxBatchTimeout: import_zod2.z.number().min(0).max(30).optional(),
+  maxBatchTimeout: import_zod2.z.number().min(0).max(60).optional(),
   // seconds
   maxRetires: import_zod2.z.number().min(0).max(100).optional(),
+  // deprecated
+  maxRetries: import_zod2.z.number().min(0).max(100).optional(),
   deadLetterQueue: import_zod2.z.ostring(),
   retryDelay: QueueMessageDelaySchema
+}).transform((queue) => {
+  if (queue.maxRetires !== void 0) {
+    queue.maxRetries = queue.maxRetires;
+  }
+  return queue;
 });
 var QueueConsumerSchema = /* @__PURE__ */ import_zod2.z.intersection(
   QueueConsumerOptionsSchema,
@@ -3853,8 +3865,8 @@ var Response = class extends import_undici3.Response {
     Object.setPrototypeOf(response, Response.prototype);
     return response;
   }
-  static redirect(url17, status) {
-    const response = import_undici3.Response.redirect(url17, status);
+  static redirect(url18, status) {
+    const response = import_undici3.Response.redirect(url18, status);
     Object.setPrototypeOf(response, Response.prototype);
     return response;
   }
@@ -4362,14 +4374,14 @@ async function fetch3(input, init2) {
   const requestInit = init2;
   const request = new Request(input, requestInit);
   if (request.method === "GET" && request.headers.get("upgrade") === "websocket") {
-    const url17 = new URL(request.url);
-    if (url17.protocol !== "http:" && url17.protocol !== "https:") {
+    const url18 = new URL(request.url);
+    if (url18.protocol !== "http:" && url18.protocol !== "https:") {
       throw new TypeError(
-        `Fetch API cannot load: ${url17.toString()}.
+        `Fetch API cannot load: ${url18.toString()}.
 Make sure you're using http(s):// URLs for WebSocket requests via fetch.`
       );
     }
-    url17.protocol = url17.protocol.replace("http", "ws");
+    url18.protocol = url18.protocol.replace("http", "ws");
     const headers = {};
     let protocols;
     for (const [key, value] of request.headers.entries()) {
@@ -4381,10 +4393,10 @@ Make sure you're using http(s):// URLs for WebSocket requests via fetch.`
     }
     let rejectUnauthorized;
     if (requestInit.dispatcher instanceof DispatchFetchDispatcher) {
-      requestInit.dispatcher.addHeaders(headers, url17.pathname + url17.search);
+      requestInit.dispatcher.addHeaders(headers, url18.pathname + url18.search);
       rejectUnauthorized = { rejectUnauthorized: false };
     }
-    const ws = new import_ws2.default(url17, protocols, {
+    const ws = new import_ws2.default(url18, protocols, {
       followRedirects: request.redirect === "follow",
       headers,
       ...rejectUnauthorized
@@ -4443,8 +4455,8 @@ var DispatchFetchDispatcher = class extends undici.Dispatcher {
       this.cfBlobJson = JSON.stringify(cfBlob);
   }
   cfBlobJson;
-  addHeaders(headers, path27) {
-    const originalURL = this.userRuntimeOrigin + path27;
+  addHeaders(headers, path28) {
+    const originalURL = this.userRuntimeOrigin + path28;
     addHeader(headers, CoreHeaders.ORIGINAL_URL, originalURL);
     addHeader(headers, CoreHeaders.DISABLE_PRETTY_ERROR, "true");
     if (this.cfBlobJson !== void 0) {
@@ -4457,16 +4469,16 @@ var DispatchFetchDispatcher = class extends undici.Dispatcher {
       origin = this.actualRuntimeOrigin;
     if (origin === this.actualRuntimeOrigin) {
       options.origin = origin;
-      let path27 = options.path;
+      let path28 = options.path;
       if (options.query !== void 0) {
-        const url17 = new URL(path27, "http://placeholder/");
+        const url18 = new URL(path28, "http://placeholder/");
         for (const [key, value] of Object.entries(options.query)) {
-          url17.searchParams.append(key, value);
+          url18.searchParams.append(key, value);
         }
-        path27 = url17.pathname + url17.search;
+        path28 = url18.pathname + url18.search;
       }
       options.headers ??= {};
-      this.addHeaders(options.headers, path27);
+      this.addHeaders(options.headers, path28);
       return this.runtimeDispatcher.dispatch(options, handler);
     } else {
       return this.globalDispatcher.dispatch(options, handler);
@@ -4527,11 +4539,6 @@ ez/dHA==
 `;
 
 // src/http/server.ts
-var ENTRY_SOCKET_HTTP_OPTIONS = {
-  // Even though we inject a `cf` object in the entry worker, allow it to
-  // be customised via `dispatchFetch`
-  cfBlobHeader: CoreHeaders.CF_BLOB
-};
 async function getEntrySocketHttpOptions(coreOpts) {
   let privateKey = void 0;
   let certificateChain = void 0;
@@ -4548,7 +4555,6 @@ async function getEntrySocketHttpOptions(coreOpts) {
   if (privateKey && certificateChain) {
     return {
       https: {
-        options: ENTRY_SOCKET_HTTP_OPTIONS,
         tlsOptions: {
           keypair: {
             privateKey,
@@ -4558,7 +4564,7 @@ async function getEntrySocketHttpOptions(coreOpts) {
       }
     };
   } else {
-    return { http: ENTRY_SOCKET_HTTP_OPTIONS };
+    return { http: {} };
   }
 }
 function valueOrFile(value, filePath) {
@@ -4587,7 +4593,7 @@ var import_undici4 = require("undici");
 // src/plugins/assets/index.ts
 var import_node_crypto = __toESM(require("node:crypto"));
 var import_promises7 = __toESM(require("node:fs/promises"));
-var import_node_path = __toESM(require("node:path"));
+var import_node_path2 = __toESM(require("node:path"));
 
 // ../workers-shared/utils/constants.ts
 var HEADER_SIZE = 20;
@@ -4603,7 +4609,8 @@ var MAX_ASSET_SIZE = 25 * 1024 * 1024;
 // ../workers-shared/utils/types.ts
 var import_zod4 = require("zod");
 var RoutingConfigSchema = import_zod4.z.object({
-  has_user_worker: import_zod4.z.boolean().optional()
+  has_user_worker: import_zod4.z.boolean().optional(),
+  invoke_user_worker_ahead_of_assets: import_zod4.z.boolean().optional()
 });
 var AssetConfigSchema = import_zod4.z.object({
   html_handling: import_zod4.z.enum([
@@ -4612,14 +4619,18 @@ var AssetConfigSchema = import_zod4.z.object({
     "drop-trailing-slash",
     "none"
   ]).optional(),
-  not_found_handling: import_zod4.z.enum(["single-page-application", "404-page", "none"]).optional()
+  not_found_handling: import_zod4.z.enum(["single-page-application", "404-page", "none"]).optional(),
+  serve_directly: import_zod4.z.boolean().optional()
 });
 
 // ../workers-shared/utils/helpers.ts
+var import_node_path = require("node:path");
 var import_mime = __toESM(require_mime());
-var encodeFilePath = (filePath, sep) => {
-  const encodedPath = filePath.split(sep).map((segment) => encodeURIComponent(segment)).join("/");
-  return "/" + encodedPath;
+var normalizeFilePath = (relativeFilepath) => {
+  if ((0, import_node_path.isAbsolute)(relativeFilepath)) {
+    throw new Error(`Expected relative path`);
+  }
+  return "/" + relativeFilepath.split(import_node_path.sep).join("/");
 };
 var getContentType = (absFilePath) => {
   let contentType = (0, import_mime.getType)(absFilePath) || "application/octet-stream";
@@ -4629,7 +4640,7 @@ var getContentType = (absFilePath) => {
   return contentType;
 };
 
-// ../../node_modules/.pnpm/pretty-bytes@6.0.0/node_modules/pretty-bytes/index.js
+// ../../node_modules/.pnpm/pretty-bytes@6.1.1/node_modules/pretty-bytes/index.js
 var BYTE_UNITS = [
   "B",
   "kB",
@@ -4643,7 +4654,7 @@ var BYTE_UNITS = [
 ];
 var BIBYTE_UNITS = [
   "B",
-  "kiB",
+  "KiB",
   "MiB",
   "GiB",
   "TiB",
@@ -4690,11 +4701,13 @@ function prettyBytes(number, options) {
   options = {
     bits: false,
     binary: false,
+    space: true,
     ...options
   };
   const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
+  const separator = options.space ? " " : "";
   if (options.signed && number === 0) {
-    return ` 0 ${UNITS[0]}`;
+    return ` 0${separator}${UNITS[0]}`;
   }
   const isNegative = number < 0;
   const prefix = isNegative ? "-" : options.signed ? "+" : "";
@@ -4710,7 +4723,7 @@ function prettyBytes(number, options) {
   }
   if (number < 1) {
     const numberString2 = toLocaleString(number, options.locale, localeOptions);
-    return prefix + numberString2 + " " + UNITS[0];
+    return prefix + numberString2 + separator + UNITS[0];
   }
   const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
   number /= (options.binary ? 1024 : 1e3) ** exponent;
@@ -4719,7 +4732,7 @@ function prettyBytes(number, options) {
   }
   const numberString = toLocaleString(Number(number), options.locale, localeOptions);
   const unit = UNITS[exponent];
-  return prefix + numberString + " " + unit;
+  return prefix + numberString + separator + unit;
 }
 
 // embed-worker:/home/runner/work/workers-sdk/workers-sdk/packages/miniflare/src/workers/assets/assets.worker.ts
@@ -4945,6 +4958,12 @@ var Runtime = class {
   }
 };
 
+// src/plugins/assets/constants.ts
+var ASSETS_PLUGIN_NAME = "assets";
+var ASSETS_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:assets-service`;
+var ROUTER_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:router`;
+var ASSETS_KV_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:kv`;
+
 // src/plugins/cache/index.ts
 var import_promises4 = __toESM(require("fs/promises"));
 
@@ -5069,12 +5088,12 @@ var kUnsafeEphemeralUniqueKey = Symbol.for(
 var import_url11 = require("url");
 var RouterError = class extends MiniflareError {
 };
-function routeSpecificity(url17) {
-  const hostParts = url17.host.split(".");
+function routeSpecificity(url18) {
+  const hostParts = url18.host.split(".");
   let hostScore = hostParts.length;
   if (hostParts[0] === "*")
     hostScore -= 2;
-  const pathParts = url17.pathname.split("/");
+  const pathParts = url18.pathname.split("/");
   let pathScore = pathParts.length;
   if (pathParts[pathParts.length - 1] === "*")
     pathScore -= 2;
@@ -5088,30 +5107,30 @@ function parseRoutes(allRoutes) {
       let urlInput = route;
       if (!hasProtocol)
         urlInput = `https://${urlInput}`;
-      const url17 = new import_url11.URL(urlInput);
-      const specificity = routeSpecificity(url17);
-      const protocol = hasProtocol ? url17.protocol : void 0;
-      const internationalisedAllowHostnamePrefix = url17.hostname.startsWith("xn--*");
-      const allowHostnamePrefix = url17.hostname.startsWith("*") || internationalisedAllowHostnamePrefix;
-      const anyHostname = url17.hostname === "*";
+      const url18 = new import_url11.URL(urlInput);
+      const specificity = routeSpecificity(url18);
+      const protocol = hasProtocol ? url18.protocol : void 0;
+      const internationalisedAllowHostnamePrefix = url18.hostname.startsWith("xn--*");
+      const allowHostnamePrefix = url18.hostname.startsWith("*") || internationalisedAllowHostnamePrefix;
+      const anyHostname = url18.hostname === "*";
       if (allowHostnamePrefix && !anyHostname) {
-        let hostname = url17.hostname;
+        let hostname = url18.hostname;
         if (internationalisedAllowHostnamePrefix) {
           hostname = (0, import_url11.domainToUnicode)(hostname);
         }
-        url17.hostname = hostname.substring(1);
+        url18.hostname = hostname.substring(1);
       }
-      const allowPathSuffix = url17.pathname.endsWith("*");
+      const allowPathSuffix = url18.pathname.endsWith("*");
       if (allowPathSuffix) {
-        url17.pathname = url17.pathname.substring(0, url17.pathname.length - 1);
+        url18.pathname = url18.pathname.substring(0, url18.pathname.length - 1);
       }
-      if (url17.search) {
+      if (url18.search) {
         throw new RouterError(
           "ERR_QUERY_STRING",
           `Route "${route}" for "${target}" contains a query string. This is not allowed.`
         );
       }
-      if (url17.toString().includes("*") && !anyHostname) {
+      if (url18.toString().includes("*") && !anyHostname) {
         throw new RouterError(
           "ERR_INFIX_WILDCARD",
           `Route "${route}" for "${target}" contains an infix wildcard. This is not allowed.`
@@ -5123,8 +5142,8 @@ function parseRoutes(allRoutes) {
         specificity,
         protocol,
         allowHostnamePrefix,
-        hostname: anyHostname ? "" : url17.hostname,
-        path: url17.pathname,
+        hostname: anyHostname ? "" : url18.hostname,
+        path: url18.pathname,
         allowPathSuffix
       });
     }
@@ -5165,11 +5184,11 @@ function namespaceEntries(namespaces) {
     return [];
   }
 }
-function maybeParseURL(url17) {
-  if (typeof url17 !== "string" || import_path14.default.isAbsolute(url17))
+function maybeParseURL(url18) {
+  if (typeof url18 !== "string" || import_path14.default.isAbsolute(url18))
     return;
   try {
-    return new URL(url17);
+    return new URL(url18);
   } catch {
   }
 }
@@ -5178,16 +5197,16 @@ function getPersistPath(pluginName, tmpPath, persist) {
   if (persist === void 0 || persist === false) {
     return memoryishPath;
   }
-  const url17 = maybeParseURL(persist);
-  if (url17 !== void 0) {
-    if (url17.protocol === "memory:") {
+  const url18 = maybeParseURL(persist);
+  if (url18 !== void 0) {
+    if (url18.protocol === "memory:") {
       return memoryishPath;
-    } else if (url17.protocol === "file:") {
-      return (0, import_url12.fileURLToPath)(url17);
+    } else if (url18.protocol === "file:") {
+      return (0, import_url12.fileURLToPath)(url18);
     }
     throw new MiniflareCoreError(
       "ERR_PERSIST_UNSUPPORTED",
-      `Unsupported "${url17.protocol}" persistence protocol for storage: ${url17.href}`
+      `Unsupported "${url18.protocol}" persistence protocol for storage: ${url18.href}`
     );
   }
   return persist === true ? import_path14.default.join(DEFAULT_PERSIST_ROOT, pluginName) : persist;
@@ -5482,6 +5501,51 @@ var import_util = require("util");
 var import_acorn = require("acorn");
 var import_acorn_walk = require("acorn-walk");
 var import_zod9 = require("zod");
+
+// src/plugins/core/node-compat.ts
+function getNodeCompat(compatibilityDate = "2000-01-01", compatibilityFlags, opts) {
+  const { nodeCompat = false } = opts ?? {};
+  const {
+    hasNodejsAlsFlag,
+    hasNodejsCompatFlag,
+    hasNodejsCompatV2Flag,
+    hasNoNodejsCompatV2Flag,
+    hasExperimentalNodejsCompatV2Flag
+  } = parseNodeCompatibilityFlags(compatibilityFlags);
+  const nodeCompatSwitchOverDate = "2024-09-23";
+  const legacy = nodeCompat === true;
+  let mode = null;
+  if (hasNodejsCompatV2Flag || hasNodejsCompatFlag && compatibilityDate >= nodeCompatSwitchOverDate && !hasNoNodejsCompatV2Flag) {
+    mode = "v2";
+  } else if (hasNodejsCompatFlag) {
+    mode = "v1";
+  } else if (hasNodejsAlsFlag) {
+    mode = "als";
+  } else if (legacy) {
+    mode = "legacy";
+  }
+  return {
+    mode,
+    hasNodejsAlsFlag,
+    hasNodejsCompatFlag,
+    hasNodejsCompatV2Flag,
+    hasNoNodejsCompatV2Flag,
+    hasExperimentalNodejsCompatV2Flag
+  };
+}
+function parseNodeCompatibilityFlags(compatibilityFlags) {
+  return {
+    hasNodejsAlsFlag: compatibilityFlags.includes("nodejs_als"),
+    hasNodejsCompatFlag: compatibilityFlags.includes("nodejs_compat"),
+    hasNodejsCompatV2Flag: compatibilityFlags.includes("nodejs_compat_v2"),
+    hasNoNodejsCompatV2Flag: compatibilityFlags.includes("no_nodejs_compat_v2"),
+    hasExperimentalNodejsCompatV2Flag: compatibilityFlags.includes(
+      "experimental:nodejs_compat_v2"
+    )
+  };
+}
+
+// src/plugins/core/modules.ts
 var SUGGEST_BUNDLE = "If you're trying to import an npm package, you'll need to bundle your Worker first.";
 var SUGGEST_NODE = "If you're trying to import a Node.js built-in module, or an npm package that uses Node.js built-ins, you'll either need to:\n- Bundle your Worker, configuring your bundler to polyfill Node.js built-ins\n- Configure your bundler to load Workers-compatible builds by changing the main fields/conditions\n- Enable the `nodejs_compat` compatibility flag and use the `NodeJsCompatModule` module type\n- Find an alternative package that doesn't require Node.js built-ins";
 var builtinModulesWithPrefix = import_module.builtinModules.concat(
@@ -5589,15 +5653,18 @@ function getResolveErrorPrefix(referencingPath) {
   return `Unable to resolve "${relative}" dependency`;
 }
 var ModuleLocator = class {
-  constructor(modulesRoot, additionalModuleNames, rules = [], compatibilityFlags) {
+  constructor(modulesRoot, additionalModuleNames, rules = [], compatibilityDate, compatibilityFlags) {
     this.modulesRoot = modulesRoot;
     this.additionalModuleNames = additionalModuleNames;
     rules = rules.concat(DEFAULT_MODULE_RULES);
     this.#compiledRules = compileModuleRules(rules);
-    this.#nodejsCompat = compatibilityFlags?.includes("nodejs_compat") ?? false;
+    this.#nodejsCompatMode = getNodeCompat(
+      compatibilityDate,
+      compatibilityFlags ?? []
+    ).mode;
   }
   #compiledRules;
-  #nodejsCompat;
+  #nodejsCompatMode;
   #visitedPaths = /* @__PURE__ */ new Set();
   modules = [];
   visitEntrypoint(code, modulePath) {
@@ -5681,7 +5748,14 @@ ${dim(modulesConfig)}`;
     }
     const spec = specExpression.value;
     const isNodeJsCompatModule = referencingType === "NodeJsCompatModule";
-    if (this.#nodejsCompat && spec.startsWith("node:") || spec.startsWith("cloudflare:") || spec.startsWith("workerd:") || isNodeJsCompatModule && builtinModulesWithPrefix.includes(spec) || this.additionalModuleNames.includes(spec)) {
+    if (
+      // `cloudflare:` and `workerd:` imports don't need to be included explicitly
+      spec.startsWith("cloudflare:") || spec.startsWith("workerd:") || // Node.js compat v1 requires imports to be prefixed with `node:`
+      this.#nodejsCompatMode === "v1" && spec.startsWith("node:") || // Node.js compat modules and v2 can also handle non-prefixed imports
+      (this.#nodejsCompatMode === "v2" || isNodeJsCompatModule) && builtinModulesWithPrefix.includes(spec) || // Async Local Storage mode (node_als) only deals with `node:async_hooks` imports
+      this.#nodejsCompatMode === "als" && spec === "node:async_hooks" || // Any "additional" external modules can be ignored
+      this.additionalModuleNames.includes(spec)
+    ) {
       return;
     }
     if (maybeGetStringScriptPathIndex(referencingName) !== void 0) {
@@ -5752,60 +5826,60 @@ function createJavaScriptModule(code, name, modulePath, type) {
 }
 var encoder = new import_util.TextEncoder();
 var decoder = new import_util.TextDecoder();
-function contentsToString(contents17) {
-  return typeof contents17 === "string" ? contents17 : decoder.decode(contents17);
+function contentsToString(contents18) {
+  return typeof contents18 === "string" ? contents18 : decoder.decode(contents18);
 }
-function contentsToArray(contents17) {
-  return typeof contents17 === "string" ? encoder.encode(contents17) : contents17;
+function contentsToArray(contents18) {
+  return typeof contents18 === "string" ? encoder.encode(contents18) : contents18;
 }
 function convertModuleDefinition(modulesRoot, def) {
   const name = moduleName(modulesRoot, def.path);
-  const contents17 = def.contents ?? (0, import_fs12.readFileSync)(def.path);
+  const contents18 = def.contents ?? (0, import_fs12.readFileSync)(def.path);
   switch (def.type) {
     case "ESModule":
     case "CommonJS":
     case "NodeJsCompatModule":
       return createJavaScriptModule(
-        contentsToString(contents17),
+        contentsToString(contents18),
         name,
         import_path15.default.resolve(modulesRoot, def.path),
         def.type
       );
     case "Text":
-      return { name, text: contentsToString(contents17) };
+      return { name, text: contentsToString(contents18) };
     case "Data":
-      return { name, data: contentsToArray(contents17) };
+      return { name, data: contentsToArray(contents18) };
     case "CompiledWasm":
-      return { name, wasm: contentsToArray(contents17) };
+      return { name, wasm: contentsToArray(contents18) };
     case "PythonModule":
-      return { name, pythonModule: contentsToString(contents17) };
+      return { name, pythonModule: contentsToString(contents18) };
     case "PythonRequirement":
-      return { name, pythonRequirement: contentsToString(contents17) };
+      return { name, pythonRequirement: contentsToString(contents18) };
     default:
       const exhaustive = def.type;
       import_assert5.default.fail(`Unreachable: ${exhaustive} modules are unsupported`);
   }
 }
 function convertWorkerModule(mod) {
-  const path27 = mod.name;
-  (0, import_assert5.default)(path27 !== void 0);
+  const path28 = mod.name;
+  (0, import_assert5.default)(path28 !== void 0);
   const m = mod;
   if ("esModule" in m)
-    return { path: path27, type: "ESModule" };
+    return { path: path28, type: "ESModule" };
   else if ("commonJsModule" in m)
-    return { path: path27, type: "CommonJS" };
+    return { path: path28, type: "CommonJS" };
   else if ("nodeJsCompatModule" in m)
-    return { path: path27, type: "NodeJsCompatModule" };
+    return { path: path28, type: "NodeJsCompatModule" };
   else if ("text" in m)
-    return { path: path27, type: "Text" };
+    return { path: path28, type: "Text" };
   else if ("data" in m)
-    return { path: path27, type: "Data" };
+    return { path: path28, type: "Data" };
   else if ("wasm" in m)
-    return { path: path27, type: "CompiledWasm" };
+    return { path: path28, type: "CompiledWasm" };
   else if ("pythonModule" in m)
-    return { path: path27, type: "PythonModule" };
+    return { path: path28, type: "PythonModule" };
   else if ("pythonRequirement" in m)
-    return { path: path27, type: "PythonRequirement" };
+    return { path: path28, type: "PythonRequirement" };
   (0, import_assert5.default)(
     !("json" in m || "fallbackService" in m),
     "Unreachable: json or fallbackService modules aren't generated"
@@ -6008,8 +6082,8 @@ function getSourceMapper() {
 // src/plugins/core/errors/index.ts
 function maybeGetDiskFile(filePath) {
   try {
-    const contents17 = import_fs13.default.readFileSync(filePath, "utf8");
-    return { path: filePath, contents: contents17 };
+    const contents18 = import_fs13.default.readFileSync(filePath, "utf8");
+    return { path: filePath, contents: contents18 };
   } catch (e) {
     if (e.code !== "ENOENT")
       throw e;
@@ -6024,8 +6098,8 @@ function maybeGetFile(workerSrcOpts, fileSpecifier) {
         const modulesRoot = srcOpts.modulesRoot ?? "";
         for (const module2 of srcOpts.modules) {
           if (module2.contents !== void 0 && import_path16.default.resolve(modulesRoot, module2.path) === filePath) {
-            const contents17 = contentsToString(module2.contents);
-            return { path: filePath, contents: contents17 };
+            const contents18 = contentsToString(module2.contents);
+            return { path: filePath, contents: contents18 };
           }
         }
       } else if ("script" in srcOpts && "scriptPath" in srcOpts && srcOpts.script !== void 0 && srcOpts.scriptPath !== void 0) {
@@ -6209,7 +6283,7 @@ var SynchronousFetcher = class {
       transferList: [this.#channel.port2]
     });
   }
-  fetch(url17, init2) {
+  fetch(url18, init2) {
     this.#ensureWorker();
     Atomics.store(
       this.#notifyHandle,
@@ -6222,7 +6296,7 @@ var SynchronousFetcher = class {
     this.#channel.port1.postMessage({
       id,
       method: init2.method,
-      url: url17.toString(),
+      url: url18.toString(),
       headers: init2.headers,
       body: init2.body
     });
@@ -6342,8 +6416,8 @@ var ProxyClient = class {
   }
 };
 var ProxyClientBridge = class {
-  constructor(url17, dispatchFetch) {
-    this.url = url17;
+  constructor(url18, dispatchFetch) {
+    this.url = url18;
     this.dispatchFetch = dispatchFetch;
     this.#finalizationRegistry = new FinalizationRegistry(this.#finalizeProxy);
   }
@@ -6866,7 +6940,11 @@ var CoreOptionsSchemaInput = import_zod12.z.intersection(
     unsafeEphemeralDurableObjects: import_zod12.z.boolean().optional(),
     unsafeDirectSockets: UnsafeDirectSocketSchema.array().optional(),
     unsafeEvalBinding: import_zod12.z.string().optional(),
-    unsafeUseModuleFallbackService: import_zod12.z.boolean().optional()
+    unsafeUseModuleFallbackService: import_zod12.z.boolean().optional(),
+    /** Used to set the vitest pool worker SELF binding to point to the router worker if there are assets.
+     (If there are assets but we're not using vitest, the miniflare entry worker can point directly to RW.)
+     */
+    hasAssetsAndIsVitest: import_zod12.z.boolean().optional()
   })
 );
 var CoreOptionsSchema = CoreOptionsSchemaInput.transform((value) => {
@@ -6931,7 +7009,7 @@ var SCRIPT_CUSTOM_SERVICE = `addEventListener("fetch", (event) => {
   request.headers.set("${CoreHeaders.ORIGINAL_URL}", request.url);
   event.respondWith(${CoreBindings.SERVICE_LOOPBACK}.fetch(request));
 })`;
-function getCustomServiceDesignator(refererName, workerIndex, kind, name, service) {
+function getCustomServiceDesignator(refererName, workerIndex, kind, name, service, hasAssetsAndIsVitest = false) {
   let serviceName;
   let entrypoint;
   if (typeof service === "function") {
@@ -6948,7 +7026,7 @@ function getCustomServiceDesignator(refererName, workerIndex, kind, name, servic
       serviceName = getBuiltinServiceName(workerIndex, kind, name);
     }
   } else if (service === kCurrentWorker) {
-    serviceName = getUserServiceName(refererName);
+    serviceName = hasAssetsAndIsVitest ? ROUTER_SERVICE_NAME : getUserServiceName(refererName);
   } else {
     serviceName = getUserServiceName(service);
   }
@@ -7037,7 +7115,7 @@ var CORE_PLUGIN = {
     if (options.textBlobBindings !== void 0) {
       bindings.push(
         ...Object.entries(options.textBlobBindings).map(
-          ([name, path27]) => import_promises6.default.readFile(path27, "utf8").then((text) => ({ name, text }))
+          ([name, path28]) => import_promises6.default.readFile(path28, "utf8").then((text) => ({ name, text }))
         )
       );
     }
@@ -7059,7 +7137,8 @@ var CORE_PLUGIN = {
               workerIndex,
               "#" /* UNKNOWN */,
               name,
-              service
+              service,
+              options.hasAssetsAndIsVitest
             )
           };
         })
@@ -7109,7 +7188,7 @@ var CORE_PLUGIN = {
     if (options.textBlobBindings !== void 0) {
       bindingEntries2.push(
         ...Object.entries(options.textBlobBindings).map(
-          ([name, path27]) => import_promises6.default.readFile(path27, "utf8").then((text) => [name, text])
+          ([name, path28]) => import_promises6.default.readFile(path28, "utf8").then((text) => [name, text])
         )
       );
     }
@@ -7281,7 +7360,8 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
             workerIndex,
             "$" /* KNOWN */,
             CUSTOM_SERVICE_KNOWN_OUTBOUND,
-            options.outboundService
+            options.outboundService,
+            options.hasAssetsAndIsVitest
           ),
           cacheApiOutbound: { name: getCacheServiceName(workerIndex) },
           moduleFallback: options.unsafeUseModuleFallbackService && sharedOptions.unsafeModuleFallbackService !== void 0 ? `localhost:${loopbackPort}` : void 0
@@ -7444,6 +7524,7 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
       modulesRoot,
       additionalModuleNames,
       options.modulesRules,
+      options.compatibilityDate,
       options.compatibilityFlags
     );
     locator.visitEntrypoint(code, scriptPath);
@@ -7454,21 +7535,17 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
   }
 }
 
-// src/plugins/assets/constants.ts
-var ASSETS_PLUGIN_NAME = "assets";
-var ASSETS_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:assets-service`;
-var ROUTER_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:router`;
-var ASSETS_KV_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:kv`;
-
 // src/plugins/assets/schema.ts
 var import_zod13 = require("zod");
 var AssetsOptionsSchema = import_zod13.z.object({
   assets: import_zod13.z.object({
+    // User worker name or vitest runner - this is only ever set inside miniflare
+    // The assets plugin needs access to the worker name to create the router worker - user worker binding
     workerName: import_zod13.z.string().optional(),
-    path: PathSchema,
-    bindingName: import_zod13.z.string().optional(),
-    routingConfig: RoutingConfigSchema,
-    assetConfig: AssetConfigSchema
+    directory: PathSchema,
+    binding: import_zod13.z.string().optional(),
+    routingConfig: RoutingConfigSchema.optional(),
+    assetConfig: AssetConfigSchema.optional()
   }).optional()
 });
 
@@ -7476,35 +7553,37 @@ var AssetsOptionsSchema = import_zod13.z.object({
 var ASSETS_PLUGIN = {
   options: AssetsOptionsSchema,
   async getBindings(options) {
-    if (!options.assets?.bindingName) {
+    if (!options.assets?.binding) {
       return [];
     }
     return [
       {
         // binding between User Worker and Asset Worker
-        name: options.assets.bindingName,
+        name: options.assets.binding,
         service: { name: ASSETS_SERVICE_NAME }
       }
     ];
   },
   async getNodeBindings(options) {
-    if (!options.assets?.bindingName) {
+    if (!options.assets?.binding) {
       return {};
     }
     return {
-      [options.assets.bindingName]: new ProxyNodeBinding()
+      [options.assets.binding]: new ProxyNodeBinding()
     };
   },
   async getServices({ options }) {
     if (!options.assets) {
       return [];
     }
-    const assetsReverseMap = await createReverseMap(options.assets?.path);
     const storageServiceName = `${ASSETS_PLUGIN_NAME}:storage`;
     const storageService = {
       name: storageServiceName,
-      disk: { path: options.assets.path, writable: true }
+      disk: { path: options.assets.directory, writable: true }
     };
+    const { encodedAssetManifest, assetsReverseMap } = await buildAssetManifest(
+      options.assets.directory
+    );
     const namespaceService = {
       name: ASSETS_KV_SERVICE_NAME,
       worker: {
@@ -7523,12 +7602,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_REVERSE_MAP",
-            json: assetsReverseMap
+            json: JSON.stringify(assetsReverseMap)
           }
         ]
       }
     };
-    const assetsManifest = await buildAssetsManifest(options.assets.path);
     const assetService = {
       name: ASSETS_SERVICE_NAME,
       worker: {
@@ -7546,11 +7624,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_MANIFEST",
-            data: assetsManifest
+            data: encodedAssetManifest
           },
           {
             name: "CONFIG",
-            json: JSON.stringify(options.assets.assetConfig)
+            json: JSON.stringify(options.assets.assetConfig ?? {})
           }
         ]
       }
@@ -7584,20 +7662,21 @@ var ASSETS_PLUGIN = {
     return [storageService, namespaceService, assetService, routerService];
   }
 };
-var buildAssetsManifest = async (dir) => {
-  const manifest = await walk(dir);
+var buildAssetManifest = async (dir) => {
+  const { manifest, assetsReverseMap } = await walk(dir);
   const sortedAssetManifest = sortManifest(manifest);
   const encodedAssetManifest = encodeManifest(sortedAssetManifest);
-  return encodedAssetManifest;
+  return { encodedAssetManifest, assetsReverseMap };
 };
 var walk = async (dir) => {
   const files = await import_promises7.default.readdir(dir, { recursive: true });
   const manifest = [];
+  const assetsReverseMap = {};
   let counter = 0;
   await Promise.all(
     files.map(async (file) => {
-      const filepath = import_node_path.default.join(dir, file);
-      const relativeFilepath = import_node_path.default.relative(dir, filepath);
+      const filepath = import_node_path2.default.join(dir, file);
+      const relativeFilepath = import_node_path2.default.relative(dir, filepath);
       const filestat = await import_promises7.default.stat(filepath);
       if (filestat.isSymbolicLink() || filestat.isDirectory()) {
         return;
@@ -7619,9 +7698,19 @@ Cloudflare Workers supports assets with sizes of up to ${prettyBytes(
 Ensure all assets in your assets directory "${dir}" conform with the Workers maximum size requirement.`
           );
         }
-        manifest.push(
-          await hashPath(encodeFilePath(relativeFilepath, import_node_path.default.sep))
-        );
+        const [pathHash, contentHash] = await Promise.all([
+          hashPath(normalizeFilePath(relativeFilepath)),
+          // used absolute filepath here so that changes to the enclosing asset folder will be registered
+          hashPath(filepath + filestat.mtimeMs.toString())
+        ]);
+        manifest.push({
+          pathHash,
+          contentHash
+        });
+        assetsReverseMap[bytesToHex(contentHash)] = {
+          filePath: relativeFilepath,
+          contentType: getContentType(filepath)
+        };
         counter++;
       }
     })
@@ -7633,23 +7722,23 @@ Cloudflare Workers supports up to ${MAX_ASSET_COUNT.toLocaleString()} assets in
 Ensure your assets directory contains a maximum of ${MAX_ASSET_COUNT.toLocaleString()} files, and that you have specified your assets directory correctly.`
     );
   }
-  return manifest;
+  return { manifest, assetsReverseMap };
 };
 var sortManifest = (manifest) => {
   return manifest.sort(comparisonFn);
 };
 var comparisonFn = (a, b) => {
-  if (a.length < b.length) {
+  if (a.pathHash.length < b.pathHash.length) {
     return -1;
   }
-  if (a.length > b.length) {
+  if (a.pathHash.length > b.pathHash.length) {
     return 1;
   }
-  for (const [i, v] of a.entries()) {
-    if (v < b[i]) {
+  for (const [i, v] of a.pathHash.entries()) {
+    if (v < b.pathHash[i]) {
       return -1;
     }
-    if (v > b[i]) {
+    if (v > b.pathHash[i]) {
       return 1;
     }
   }
@@ -7661,40 +7750,20 @@ var encodeManifest = (manifest) => {
   );
   for (const [i, entry] of manifest.entries()) {
     const entryOffset = HEADER_SIZE + i * ENTRY_SIZE;
-    assetManifestBytes.set(entry, entryOffset + PATH_HASH_OFFSET);
-    assetManifestBytes.set(entry, entryOffset + CONTENT_HASH_OFFSET);
+    assetManifestBytes.set(entry.pathHash, entryOffset + PATH_HASH_OFFSET);
+    assetManifestBytes.set(
+      entry.contentHash,
+      entryOffset + CONTENT_HASH_OFFSET
+    );
   }
   return assetManifestBytes;
 };
-var createReverseMap = async (dir) => {
-  const files = await import_promises7.default.readdir(dir, { recursive: true });
-  const assetsReverseMap = {};
-  await Promise.all(
-    files.map(async (file) => {
-      const filepath = import_node_path.default.join(dir, file);
-      const relativeFilepath = import_node_path.default.relative(dir, filepath);
-      const filestat = await import_promises7.default.stat(filepath);
-      if (filestat.isSymbolicLink() || filestat.isDirectory()) {
-        return;
-      } else {
-        const pathHash = bytesToHex(
-          await hashPath(encodeFilePath(relativeFilepath, import_node_path.default.sep))
-        );
-        assetsReverseMap[pathHash] = {
-          filePath: relativeFilepath,
-          contentType: getContentType(filepath)
-        };
-      }
-    })
-  );
-  return JSON.stringify(assetsReverseMap);
-};
 var bytesToHex = (buffer) => {
   return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
 };
-var hashPath = async (path27) => {
+var hashPath = async (path28) => {
   const encoder3 = new TextEncoder();
-  const data = encoder3.encode(path27);
+  const data = encoder3.encode(path28);
   const hashBuffer = await import_node_crypto.default.subtle.digest("SHA-256", data.buffer);
   return new Uint8Array(hashBuffer, 0, PATH_HASH_SIZE);
 };
@@ -7835,55 +7904,55 @@ var D1_PLUGIN = {
 var import_node_assert3 = __toESM(require("node:assert"));
 var import_zod15 = require("zod");
 var HYPERDRIVE_PLUGIN_NAME = "hyperdrive";
-function hasPostgresProtocol(url17) {
-  return url17.protocol === "postgresql:" || url17.protocol === "postgres:";
+function hasPostgresProtocol(url18) {
+  return url18.protocol === "postgresql:" || url18.protocol === "postgres:";
 }
-function getPort(url17) {
-  if (url17.port !== "")
-    return url17.port;
-  if (hasPostgresProtocol(url17))
+function getPort(url18) {
+  if (url18.port !== "")
+    return url18.port;
+  if (hasPostgresProtocol(url18))
     return "5432";
-  import_node_assert3.default.fail(`Expected known protocol, got ${url17.protocol}`);
+  import_node_assert3.default.fail(`Expected known protocol, got ${url18.protocol}`);
 }
-var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url17, ctx) => {
-  if (typeof url17 === "string")
-    url17 = new URL(url17);
-  if (url17.protocol === "") {
+var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url18, ctx) => {
+  if (typeof url18 === "string")
+    url18 = new URL(url18);
+  if (url18.protocol === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must specify the database protocol - e.g. 'postgresql'."
     });
-  } else if (!hasPostgresProtocol(url17)) {
+  } else if (!hasPostgresProtocol(url18)) {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "Only PostgreSQL or PostgreSQL compatible databases are currently supported."
     });
   }
-  if (url17.host === "") {
+  if (url18.host === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a hostname or IP address in your connection string - e.g. 'user:password@database-hostname.example.com:5432/databasename"
     });
   }
-  if (url17.pathname === "") {
+  if (url18.pathname === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a database name as the path component - e.g. /postgres"
     });
   }
-  if (url17.username === "") {
+  if (url18.username === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a username - e.g. 'user:password@database.example.com:port/databasename'"
     });
   }
-  if (url17.password === "") {
+  if (url18.password === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a password - e.g. 'user:password@database.example.com:port/databasename' "
     });
   }
-  return url17;
+  return url18;
 });
 var HyperdriveInputOptionsSchema = import_zod15.z.object({
   hyperdrives: import_zod15.z.record(import_zod15.z.string(), HyperdriveSchema).optional()
@@ -7892,9 +7961,9 @@ var HYPERDRIVE_PLUGIN = {
   options: HyperdriveInputOptionsSchema,
   getBindings(options) {
     return Object.entries(options.hyperdrives ?? {}).map(
-      ([name, url17]) => {
-        const database = url17.pathname.replace("/", "");
-        const scheme = url17.protocol.replace(":", "");
+      ([name, url18]) => {
+        const database = url18.pathname.replace("/", "");
+        const scheme = url18.protocol.replace(":", "");
         return {
           name,
           hyperdrive: {
@@ -7902,8 +7971,8 @@ var HYPERDRIVE_PLUGIN = {
               name: `${HYPERDRIVE_PLUGIN_NAME}:${name}`
             },
             database: decodeURIComponent(database),
-            user: decodeURIComponent(url17.username),
-            password: decodeURIComponent(url17.password),
+            user: decodeURIComponent(url18.username),
+            password: decodeURIComponent(url18.password),
             scheme
           }
         };
@@ -7912,11 +7981,11 @@ var HYPERDRIVE_PLUGIN = {
   },
   getNodeBindings(options) {
     return Object.fromEntries(
-      Object.entries(options.hyperdrives ?? {}).map(([name, url17]) => {
+      Object.entries(options.hyperdrives ?? {}).map(([name, url18]) => {
         const connectionOverrides = {
-          connectionString: `${url17}`,
-          port: Number.parseInt(url17.port),
-          host: url17.hostname
+          connectionString: `${url18}`,
+          port: Number.parseInt(url18.port),
+          host: url18.hostname
         };
         const proxyNodeBinding = new ProxyNodeBinding({
           get(target, prop) {
@@ -7929,10 +7998,10 @@ var HYPERDRIVE_PLUGIN = {
   },
   async getServices({ options }) {
     return Object.entries(options.hyperdrives ?? {}).map(
-      ([name, url17]) => ({
+      ([name, url18]) => ({
         name: `${HYPERDRIVE_PLUGIN_NAME}:${name}`,
         external: {
-          address: `${url17.hostname}:${getPort(url17)}`,
+          address: `${url18.hostname}:${getPort(url18)}`,
           tcp: {}
         }
       })
@@ -8266,7 +8335,11 @@ var QUEUES_PLUGIN = {
           { name: "broker.worker.js", esModule: broker_worker_default() }
         ],
         durableObjectNamespaces: [
-          { className: QUEUE_BROKER_OBJECT_CLASS_NAME, uniqueKey }
+          {
+            className: QUEUE_BROKER_OBJECT_CLASS_NAME,
+            uniqueKey,
+            preventEviction: true
+          }
         ],
         // Miniflare's Queue broker is in-memory only at the moment
         durableObjectStorage: { inMemory: kVoid },
@@ -8529,6 +8602,125 @@ var RATELIMIT_PLUGIN = {
   }
 };
 
+// src/plugins/workflows/index.ts
+var import_promises12 = __toESM(require("fs/promises"));
+
+// embed-worker:/home/runner/work/workers-sdk/workers-sdk/packages/miniflare/src/workers/workflows/binding.worker.ts
+var import_fs21 = __toESM(require("fs"));
+var import_path25 = __toESM(require("path"));
+var import_url21 = __toESM(require("url"));
+var contents17;
+function binding_worker_default() {
+  if (contents17 !== void 0)
+    return contents17;
+  const filePath = import_path25.default.join(__dirname, "workers", "workflows/binding.worker.js");
+  contents17 = import_fs21.default.readFileSync(filePath, "utf8") + "//# sourceURL=" + import_url21.default.pathToFileURL(filePath);
+  return contents17;
+}
+
+// src/plugins/workflows/index.ts
+var import_zod20 = require("zod");
+var WorkflowsOptionsSchema = import_zod20.z.object({
+  workflows: import_zod20.z.record(
+    import_zod20.z.object({
+      name: import_zod20.z.string(),
+      className: import_zod20.z.string(),
+      scriptName: import_zod20.z.string().optional()
+    })
+  ).optional()
+});
+var WorkflowsSharedOptionsSchema = import_zod20.z.object({
+  workflowsPersist: PersistenceSchema
+});
+var WORKFLOWS_PLUGIN_NAME = "workflows";
+var WORKFLOWS_STORAGE_SERVICE_NAME = `${WORKFLOWS_PLUGIN_NAME}:storage`;
+var WORKFLOWS_PLUGIN = {
+  options: WorkflowsOptionsSchema,
+  sharedOptions: WorkflowsSharedOptionsSchema,
+  async getBindings(options) {
+    return Object.entries(options.workflows ?? {}).map(
+      ([bindingName, workflow]) => ({
+        name: bindingName,
+        service: {
+          name: `${WORKFLOWS_PLUGIN_NAME}:${workflow.name}`,
+          entrypoint: "WorkflowBinding"
+        }
+      })
+    );
+  },
+  async getNodeBindings(options) {
+    return Object.fromEntries(
+      Object.keys(options.workflows ?? {}).map((bindingName) => [
+        bindingName,
+        new ProxyNodeBinding()
+      ])
+    );
+  },
+  async getServices({ options, sharedOptions, tmpPath }) {
+    const persistPath = getPersistPath(
+      WORKFLOWS_PLUGIN_NAME,
+      tmpPath,
+      sharedOptions.workflowsPersist
+    );
+    await import_promises12.default.mkdir(persistPath, { recursive: true });
+    const storageServices = Object.entries(
+      options.workflows ?? {}
+    ).map(([_, workflow]) => ({
+      name: `${WORKFLOWS_STORAGE_SERVICE_NAME}-${workflow.name}`,
+      disk: { path: persistPath, writable: true }
+    }));
+    const services = Object.entries(options.workflows ?? {}).map(
+      ([_bindingName, workflow]) => {
+        const uniqueKey = `miniflare-workflows-${workflow.name}`;
+        const workflowsBinding = {
+          name: `${WORKFLOWS_PLUGIN_NAME}:${workflow.name}`,
+          worker: {
+            compatibilityDate: "2024-10-22",
+            modules: [
+              {
+                name: "workflows.mjs",
+                esModule: binding_worker_default()
+              }
+            ],
+            durableObjectNamespaces: [
+              {
+                className: "Engine",
+                enableSql: true,
+                uniqueKey,
+                preventEviction: true
+              }
+            ],
+            durableObjectStorage: {
+              localDisk: `${WORKFLOWS_STORAGE_SERVICE_NAME}-${workflow.name}`
+            },
+            bindings: [
+              {
+                name: "ENGINE",
+                durableObjectNamespace: { className: "Engine" }
+              },
+              {
+                name: "USER_WORKFLOW",
+                service: {
+                  name: getUserServiceName(workflow.scriptName),
+                  entrypoint: workflow.className
+                }
+              }
+            ]
+          }
+        };
+        return workflowsBinding;
+      }
+    );
+    if (services.length === 0) {
+      return [];
+    }
+    return [...storageServices, ...services];
+  },
+  getPersistPath({ workflowsPersist }, tmpPath) {
+    return getPersistPath(WORKFLOWS_PLUGIN_NAME, tmpPath, workflowsPersist);
+  }
+};
+
 // src/plugins/index.ts
 var PLUGINS = {
   [CORE_PLUGIN_NAME2]: CORE_PLUGIN,
@@ -8540,7 +8732,8 @@ var PLUGINS = {
   [R2_PLUGIN_NAME]: R2_PLUGIN,
   [HYPERDRIVE_PLUGIN_NAME]: HYPERDRIVE_PLUGIN,
   [RATELIMIT_PLUGIN_NAME]: RATELIMIT_PLUGIN,
-  [ASSETS_PLUGIN_NAME]: ASSETS_PLUGIN
+  [ASSETS_PLUGIN_NAME]: ASSETS_PLUGIN,
+  [WORKFLOWS_PLUGIN_NAME]: WORKFLOWS_PLUGIN
 };
 var PLUGIN_ENTRIES = Object.entries(PLUGINS);
 
@@ -8646,8 +8839,8 @@ function hasMultipleDistinctMessages(issues, atDepth) {
   }
   return false;
 }
-function annotate(groupCounts, annotated, input, issue, path27, groupId) {
-  if (path27.length === 0) {
+function annotate(groupCounts, annotated, input, issue, path28, groupId) {
+  if (path28.length === 0) {
     if (issue.code === "invalid_union") {
       const unionIssues = issue.unionErrors.flatMap(({ issues }) => issues);
       let newGroupId;
@@ -8694,7 +8887,7 @@ function annotate(groupCounts, annotated, input, issue, path27, groupId) {
       [kGroupId]: groupId
     };
   }
-  const [head, ...tail] = path27;
+  const [head, ...tail] = path28;
   (0, import_assert11.default)(isRecord(input), "Expected object/array input for nested issue");
   if (annotated === void 0) {
     if (Array.isArray(input)) {
@@ -8904,7 +9097,7 @@ function validateOptions(opts) {
   );
   const sharedRootPath = multipleWorkers ? getRootPath(sharedOpts) : "";
   const workerRootPaths = workerOpts.map(
-    (opts2) => import_path25.default.resolve(sharedRootPath, getRootPath(opts2))
+    (opts2) => import_path26.default.resolve(sharedRootPath, getRootPath(opts2))
   );
   try {
     for (const [key, plugin] of PLUGIN_ENTRIES) {
@@ -8920,7 +9113,7 @@ function validateOptions(opts) {
       }
     }
   } catch (e) {
-    if (e instanceof import_zod21.z.ZodError) {
+    if (e instanceof import_zod22.z.ZodError) {
       let formatted;
       try {
         formatted = formatZodError(e, opts);
@@ -9084,8 +9277,15 @@ function getQueueProducers(allWorkerOpts) {
           ])
         );
       }
-      for (const [bindingName, opts] of Object.entries(workerProducers)) {
-        queueProducers.set(bindingName, { workerName, ...opts });
+      const producersIterable = Object.entries(
+        workerProducers
+      );
+      for (const [bindingName, opts] of producersIterable) {
+        if (typeof opts === "string") {
+          queueProducers.set(bindingName, { workerName, queueName: opts });
+        } else {
+          queueProducers.set(bindingName, { workerName, ...opts });
+        }
       }
     }
   }
@@ -9325,7 +9525,7 @@ var Miniflare2 = class {
         }
       }
     });
-    this.#tmpPath = import_path25.default.join(
+    this.#tmpPath = import_path26.default.join(
       import_os2.default.tmpdir(),
       `miniflare-${import_crypto3.default.randomBytes(16).toString("hex")}`
     );
@@ -9333,7 +9533,7 @@ var Miniflare2 = class {
     this.#removeExitHook = (0, import_exit_hook.default)(() => {
       void this.#runtime?.dispose();
       try {
-        import_fs21.default.rmSync(this.#tmpPath, { force: true, recursive: true });
+        import_fs22.default.rmSync(this.#tmpPath, { force: true, recursive: true });
       } catch (e) {
         this.#log.debug(`Unable to remove temporary directory: ${String(e)}`);
       }
@@ -9370,7 +9570,7 @@ var Miniflare2 = class {
       if (!(response instanceof Response)) {
         response = new Response(response.body, response);
       }
-      return import_zod21.z.instanceof(Response).parse(response);
+      return import_zod22.z.instanceof(Response).parse(response);
     } catch (e) {
       return new Response(e?.stack ?? e, { status: 500 });
     }
@@ -9395,11 +9595,11 @@ var Miniflare2 = class {
     (0, import_assert12.default)(!Array.isArray(cfBlob));
     const cf = cfBlob ? JSON.parse(cfBlob) : void 0;
     const originalUrl = headers.get(CoreHeaders.ORIGINAL_URL);
-    const url17 = new URL(originalUrl ?? req.url ?? "", "http://localhost");
+    const url18 = new URL(originalUrl ?? req.url ?? "", "http://localhost");
     headers.delete(CoreHeaders.ORIGINAL_URL);
     const noBody = req.method === "GET" || req.method === "HEAD";
     const body = noBody ? void 0 : safeReadableStreamFrom(req);
-    const request = new Request(url17, {
+    const request = new Request(url18, {
       method: req.method,
       headers,
       body,
@@ -9420,13 +9620,13 @@ var Miniflare2 = class {
           request,
           this
         );
-      } else if (url17.pathname === "/core/error") {
+      } else if (url18.pathname === "/core/error") {
         response = await handlePrettyErrorRequest(
           this.#log,
           this.#workerSrcOpts,
           request
         );
-      } else if (url17.pathname === "/core/log") {
+      } else if (url18.pathname === "/core/log") {
         const level = parseInt(request.headers.get(SharedHeaders.LOG_LEVEL));
         (0, import_assert12.default)(
           0 /* NONE */ <= level && level <= 5 /* VERBOSE */,
@@ -9561,18 +9761,26 @@ var Miniflare2 = class {
       sockets.push({
         name: SOCKET_ENTRY_LOCAL,
         service: { name: SERVICE_ENTRY },
-        http: ENTRY_SOCKET_HTTP_OPTIONS,
+        http: {},
         address: "127.0.0.1:0"
       });
     }
     const proxyBindings = [];
     const allWorkerBindings = /* @__PURE__ */ new Map();
     const wrappedBindingsToPopulate = [];
+    if (this.#workerOpts[0].assets.assets) {
+      this.#workerOpts[0].assets.assets.workerName = this.#workerOpts[0].core.name;
+    }
     for (let i = 0; i < allWorkerOpts.length; i++) {
       const previousWorkerOpts = allPreviousWorkerOpts?.[i];
       const workerOpts = allWorkerOpts[i];
       const workerName = workerOpts.core.name ?? "";
       const isModulesWorker = Boolean(workerOpts.core.modules);
+      if (workerOpts.workflows.workflows) {
+        for (const workflow of Object.values(workerOpts.workflows.workflows)) {
+          workflow.scriptName ??= workerOpts.core.name;
+        }
+      }
       const workerBindings = [];
       allWorkerBindings.set(workerName, workerBindings);
       const additionalModules = [];
@@ -9687,8 +9895,11 @@ var Miniflare2 = class {
     const globalServices = getGlobalServices({
       sharedOptions: sharedOpts.core,
       allWorkerRoutes,
-      // if Workers + Assets project, point to router Worker service rather than user Worker
-      fallbackWorkerName: this.#workerOpts[0].assets.assets ? ROUTER_SERVICE_NAME : getUserServiceName(this.#workerOpts[0].core.name),
+      // if Workers + Assets project but NOT Vitest, point to router Worker instead
+      // if Vitest with assets, the self binding on the test runner will point to RW
+      fallbackWorkerName: this.#workerOpts[0].assets.assets && !this.#workerOpts[0].core.name?.startsWith(
+        "vitest-pool-workers-runner-"
+      ) ? ROUTER_SERVICE_NAME : getUserServiceName(this.#workerOpts[0].core.name),
       loopbackPort,
       log: this.#log,
       proxyBindings
@@ -9902,11 +10113,11 @@ var Miniflare2 = class {
     (0, import_assert12.default)(this.#runtimeEntryURL !== void 0);
     (0, import_assert12.default)(this.#runtimeDispatcher !== void 0);
     const forward = new Request(input, init2);
-    const url17 = new URL(forward.url);
+    const url18 = new URL(forward.url);
     const actualRuntimeOrigin = this.#runtimeEntryURL.origin;
-    const userRuntimeOrigin = url17.origin;
-    url17.protocol = this.#runtimeEntryURL.protocol;
-    url17.host = this.#runtimeEntryURL.host;
+    const userRuntimeOrigin = url18.origin;
+    url18.protocol = this.#runtimeEntryURL.protocol;
+    url18.host = this.#runtimeEntryURL.host;
     if (forward.body !== null && forward.headers.get("Content-Length") === "0") {
       forward.headers.delete("Content-Length");
     }
@@ -9920,7 +10131,7 @@ var Miniflare2 = class {
     );
     const forwardInit = forward;
     forwardInit.dispatcher = dispatcher;
-    const response = await fetch3(url17, forwardInit);
+    const response = await fetch3(url18, forwardInit);
     const stack = response.headers.get(CoreHeaders.ERROR_STACK);
     if (response.status === 500 && stack !== null) {
       const caught = JsonErrorSchema.parse(await response.json());
@@ -10070,7 +10281,7 @@ var Miniflare2 = class {
       await this.#proxyClient?.dispose();
       await this.#runtime?.dispose();
       await this.#stopLoopbackServer();
-      await import_fs21.default.promises.rm(this.#tmpPath, { force: true, recursive: true });
+      await import_fs22.default.promises.rm(this.#tmpPath, { force: true, recursive: true });
       maybeInstanceRegistry?.delete(this);
     }
   }
@@ -10104,7 +10315,6 @@ var Miniflare2 = class {
   DispatchFetchDispatcher,
   DurableObjectsOptionsSchema,
   DurableObjectsSharedOptionsSchema,
-  ENTRY_SOCKET_HTTP_OPTIONS,
   ErrorEvent,
   File,
   FormData,
@@ -10183,10 +10393,15 @@ var Miniflare2 = class {
   TlsOptions_Version,
   TypedEventTarget,
   WORKER_BINDING_SERVICE_LOOPBACK,
+  WORKFLOWS_PLUGIN,
+  WORKFLOWS_PLUGIN_NAME,
+  WORKFLOWS_STORAGE_SERVICE_NAME,
   WaitGroup,
   WebSocket,
   WebSocketPair,
   Worker_Binding_CryptoKey_Usage,
+  WorkflowsOptionsSchema,
+  WorkflowsSharedOptionsSchema,
   __MiniflareFunctionWrapper,
   _enableControlEndpoints,
   _forceColour,
@@ -10195,7 +10410,7 @@ var Miniflare2 = class {
   _transformsForContentEncodingAndContentType,
   base64Decode,
   base64Encode,
-  buildAssetsManifest,
+  buildAssetManifest,
   compileModuleRules,
   coupleWebSocket,
   createFetchMock,
@@ -10215,6 +10430,7 @@ var Miniflare2 = class {
   getFreshSourceMapSupport,
   getGlobalServices,
   getMiniflareObjectBindings,
+  getNodeCompat,
   getPersistPath,
   getRootPath,
   globsToRegExps,