miniflare 0.0.0-e8975a93a → 0.0.0-e8aaa3930

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;
     };
@@ -669,6 +669,24 @@ var require_workerd_capnp = __commonJS({
         capnp_ts_1.Struct.setUint16(0, 8, this);
         capnp_ts_1.Struct.setText(1, value, this);
       }
+      adoptNamedExports(value) {
+        capnp_ts_1.Struct.adopt(value, capnp_ts_1.Struct.getPointer(2, this));
+      }
+      disownNamedExports() {
+        return capnp_ts_1.Struct.disown(this.getNamedExports());
+      }
+      getNamedExports() {
+        return capnp_ts_1.Struct.getList(2, capnp.TextList, this);
+      }
+      hasNamedExports() {
+        return !capnp_ts_1.Struct.isNull(capnp_ts_1.Struct.getPointer(2, this));
+      }
+      initNamedExports(length) {
+        return capnp_ts_1.Struct.initList(2, capnp.TextList, length, this);
+      }
+      setNamedExports(value) {
+        capnp_ts_1.Struct.copyFrom(value, capnp_ts_1.Struct.getPointer(2, this));
+      }
       toString() {
         return "Worker_Module_" + super.toString();
       }
@@ -686,7 +704,7 @@ var require_workerd_capnp = __commonJS({
     Worker_Module3.NODE_JS_COMPAT_MODULE = Worker_Module_Which.NODE_JS_COMPAT_MODULE;
     Worker_Module3.PYTHON_MODULE = Worker_Module_Which.PYTHON_MODULE;
     Worker_Module3.PYTHON_REQUIREMENT = Worker_Module_Which.PYTHON_REQUIREMENT;
-    Worker_Module3._capnp = { displayName: "Module", id: "d9d87a63770a12f3", size: new capnp_ts_1.ObjectSize(8, 2) };
+    Worker_Module3._capnp = { displayName: "Module", id: "d9d87a63770a12f3", size: new capnp_ts_1.ObjectSize(8, 3) };
     var Worker_Binding_Type_Which;
     (function(Worker_Binding_Type_Which2) {
       Worker_Binding_Type_Which2[Worker_Binding_Type_Which2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -1668,6 +1686,12 @@ var require_workerd_capnp = __commonJS({
       setPreventEviction(value) {
         capnp_ts_1.Struct.setBit(16, value, this);
       }
+      getEnableSql() {
+        return capnp_ts_1.Struct.getBit(17, this);
+      }
+      setEnableSql(value) {
+        capnp_ts_1.Struct.setBit(17, value, this);
+      }
       toString() {
         return "Worker_DurableObjectNamespace_" + super.toString();
       }
@@ -2432,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,
@@ -2470,6 +2493,7 @@ __export(src_exports, {
   PersistenceSchema: () => PersistenceSchema,
   ProxyAddresses: () => ProxyAddresses,
   ProxyClient: () => ProxyClient,
+  ProxyNodeBinding: () => ProxyNodeBinding,
   ProxyOps: () => ProxyOps,
   QUEUES_PLUGIN: () => QUEUES_PLUGIN,
   QUEUES_PLUGIN_NAME: () => QUEUES_PLUGIN_NAME,
@@ -2497,7 +2521,6 @@ __export(src_exports, {
   Request: () => Request,
   Response: () => Response,
   RouterError: () => RouterError,
-  RoutingConfigSchema: () => RoutingConfigSchema,
   Runtime: () => Runtime,
   SERVICE_ENTRY: () => SERVICE_ENTRY,
   SERVICE_LOOPBACK: () => SERVICE_LOOPBACK,
@@ -2511,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,
@@ -2523,7 +2551,7 @@ __export(src_exports, {
   _transformsForContentEncodingAndContentType: () => _transformsForContentEncodingAndContentType,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
-  buildAssetsManifest: () => buildAssetsManifest,
+  buildAssetManifest: () => buildAssetManifest,
   compileModuleRules: () => compileModuleRules,
   coupleWebSocket: () => coupleWebSocket,
   createFetchMock: () => createFetchMock,
@@ -2543,6 +2571,7 @@ __export(src_exports, {
   getFreshSourceMapSupport: () => getFreshSourceMapSupport,
   getGlobalServices: () => getGlobalServices,
   getMiniflareObjectBindings: () => getMiniflareObjectBindings,
+  getNodeCompat: () => getNodeCompat,
   getPersistPath: () => getPersistPath,
   getRootPath: () => getRootPath,
   globsToRegExps: () => globsToRegExps,
@@ -2551,7 +2580,6 @@ __export(src_exports, {
   isSitesRequest: () => isSitesRequest,
   kCurrentWorker: () => kCurrentWorker,
   kInspectorSocket: () => kInspectorSocket,
-  kProxyNodeBinding: () => kProxyNodeBinding,
   kUnsafeEphemeralUniqueKey: () => kUnsafeEphemeralUniqueKey,
   kVoid: () => kVoid,
   matchRoutes: () => matchRoutes,
@@ -2588,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"));
@@ -2679,7 +2707,7 @@ function zod_worker_default() {
 
 // src/index.ts
 var import_ws3 = require("ws");
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 
 // src/cf.ts
 var import_assert = __toESM(require("assert"));
@@ -3287,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,
@@ -3421,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;
@@ -3682,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();
@@ -3759,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,
@@ -3830,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;
   }
@@ -4339,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()) {
@@ -4358,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
@@ -4420,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) {
@@ -4434,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);
@@ -4504,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;
@@ -4525,7 +4555,6 @@ async function getEntrySocketHttpOptions(coreOpts) {
   if (privateKey && certificateChain) {
     return {
       https: {
-        options: ENTRY_SOCKET_HTTP_OPTIONS,
         tlsOptions: {
           keypair: {
             privateKey,
@@ -4535,7 +4564,7 @@ async function getEntrySocketHttpOptions(coreOpts) {
       }
     };
   } else {
-    return { http: ENTRY_SOCKET_HTTP_OPTIONS };
+    return { http: {} };
   }
 }
 function valueOrFile(value, filePath) {
@@ -4564,10 +4593,54 @@ 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;
+var PATH_HASH_SIZE = 16;
+var CONTENT_HASH_SIZE = 16;
+var TAIL_SIZE = 8;
+var PATH_HASH_OFFSET = 0;
+var CONTENT_HASH_OFFSET = PATH_HASH_SIZE;
+var ENTRY_SIZE = PATH_HASH_SIZE + CONTENT_HASH_SIZE + TAIL_SIZE;
+var MAX_ASSET_COUNT = 2e4;
+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(),
+  invoke_user_worker_ahead_of_assets: import_zod4.z.boolean().optional()
+});
+var AssetConfigSchema = import_zod4.z.object({
+  html_handling: import_zod4.z.enum([
+    "auto-trailing-slash",
+    "force-trailing-slash",
+    "drop-trailing-slash",
+    "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 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";
+  if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+    contentType = `${contentType}; charset=utf-8`;
+  }
+  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",
@@ -4581,7 +4654,7 @@ var BYTE_UNITS = [
 ];
 var BIBYTE_UNITS = [
   "B",
-  "kiB",
+  "KiB",
   "MiB",
   "GiB",
   "TiB",
@@ -4628,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 ? "+" : "";
@@ -4648,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;
@@ -4657,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
@@ -4723,7 +4798,7 @@ function entry_worker_default() {
 }
 
 // src/plugins/core/index.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/runtime/index.ts
 var import_assert4 = __toESM(require("assert"));
@@ -4732,7 +4807,7 @@ var import_events2 = require("events");
 var import_readline = __toESM(require("readline"));
 var import_stream = require("stream");
 var import_workerd2 = __toESM(require("workerd"));
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/runtime/config/index.ts
 var import_capnp_ts = require("capnp-ts");
@@ -4780,15 +4855,15 @@ function serializeConfig(config) {
 }
 
 // src/runtime/index.ts
-var ControlMessageSchema = import_zod4.z.discriminatedUnion("event", [
-  import_zod4.z.object({
-    event: import_zod4.z.literal("listen"),
-    socket: import_zod4.z.string(),
-    port: import_zod4.z.number()
+var ControlMessageSchema = import_zod5.z.discriminatedUnion("event", [
+  import_zod5.z.object({
+    event: import_zod5.z.literal("listen"),
+    socket: import_zod5.z.string(),
+    port: import_zod5.z.number()
   }),
-  import_zod4.z.object({
-    event: import_zod4.z.literal("listen-inspector"),
-    port: import_zod4.z.number()
+  import_zod5.z.object({
+    event: import_zod5.z.literal("listen-inspector"),
+    port: import_zod5.z.number()
   })
 ]);
 var kInspectorSocket = Symbol("kInspectorSocket");
@@ -4883,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"));
 
@@ -4926,7 +5007,7 @@ function cache_entry_noop_worker_default() {
 }
 
 // src/plugins/cache/index.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/plugins/shared/index.ts
 var import_crypto = __toESM(require("crypto"));
@@ -4934,7 +5015,7 @@ var import_fs11 = require("fs");
 var import_promises3 = __toESM(require("fs/promises"));
 var import_path14 = __toESM(require("path"));
 var import_url12 = require("url");
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // embed-worker:/home/runner/work/workers-sdk/workers-sdk/packages/miniflare/src/workers/shared/object-entry.worker.ts
 var import_fs10 = __toESM(require("fs"));
@@ -5007,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;
@@ -5026,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.`
@@ -5061,8 +5142,8 @@ function parseRoutes(allRoutes) {
         specificity,
         protocol,
         allowHostnamePrefix,
-        hostname: anyHostname ? "" : url17.hostname,
-        path: url17.pathname,
+        hostname: anyHostname ? "" : url18.hostname,
+        path: url18.pathname,
         allowPathSuffix
       });
     }
@@ -5079,8 +5160,12 @@ function parseRoutes(allRoutes) {
 
 // src/plugins/shared/index.ts
 var DEFAULT_PERSIST_ROOT = ".mf";
-var PersistenceSchema = import_zod5.z.union([import_zod5.z.boolean(), import_zod5.z.string().url(), PathSchema]).optional();
-var kProxyNodeBinding = Symbol("kProxyNodeBinding");
+var PersistenceSchema = import_zod6.z.union([import_zod6.z.boolean(), import_zod6.z.string().url(), PathSchema]).optional();
+var ProxyNodeBinding = class {
+  constructor(proxyOverrideHandler) {
+    this.proxyOverrideHandler = proxyOverrideHandler;
+  }
+};
 function namespaceKeys(namespaces) {
   if (Array.isArray(namespaces)) {
     return namespaces;
@@ -5099,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 {
   }
 }
@@ -5112,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;
@@ -5164,11 +5249,11 @@ async function migrateDatabase(log, uniqueKey, persistPath, namespace) {
 }
 
 // src/plugins/cache/index.ts
-var CacheOptionsSchema = import_zod6.z.object({
-  cache: import_zod6.z.boolean().optional(),
-  cacheWarnUsage: import_zod6.z.boolean().optional()
+var CacheOptionsSchema = import_zod7.z.object({
+  cache: import_zod7.z.boolean().optional(),
+  cacheWarnUsage: import_zod7.z.boolean().optional()
 });
-var CacheSharedOptionsSchema = import_zod6.z.object({
+var CacheSharedOptionsSchema = import_zod7.z.object({
   cachePersist: PersistenceSchema
 });
 var CACHE_PLUGIN_NAME = "cache";
@@ -5287,35 +5372,43 @@ var CACHE_PLUGIN = {
 
 // src/plugins/do/index.ts
 var import_promises5 = __toESM(require("fs/promises"));
-var import_zod7 = require("zod");
-var DurableObjectsOptionsSchema = import_zod7.z.object({
-  durableObjects: import_zod7.z.record(
-    import_zod7.z.union([
-      import_zod7.z.string(),
-      import_zod7.z.object({
-        className: import_zod7.z.string(),
-        scriptName: import_zod7.z.string().optional(),
+var import_zod8 = require("zod");
+var DurableObjectsOptionsSchema = import_zod8.z.object({
+  durableObjects: import_zod8.z.record(
+    import_zod8.z.union([
+      import_zod8.z.string(),
+      import_zod8.z.object({
+        className: import_zod8.z.string(),
+        scriptName: import_zod8.z.string().optional(),
+        useSQLite: import_zod8.z.boolean().optional(),
         // Allow `uniqueKey` to be customised. We use in Wrangler when setting
         // up stub Durable Objects that proxy requests to Durable Objects in
         // another `workerd` process, to ensure the IDs created by the stub
         // object can be used by the real object too.
-        unsafeUniqueKey: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.literal(kUnsafeEphemeralUniqueKey)]).optional(),
+        unsafeUniqueKey: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.literal(kUnsafeEphemeralUniqueKey)]).optional(),
         // Prevents the Durable Object being evicted.
-        unsafePreventEviction: import_zod7.z.boolean().optional()
+        unsafePreventEviction: import_zod8.z.boolean().optional()
       })
     ])
   ).optional()
 });
-var DurableObjectsSharedOptionsSchema = import_zod7.z.object({
+var DurableObjectsSharedOptionsSchema = import_zod8.z.object({
   durableObjectsPersist: PersistenceSchema
 });
 function normaliseDurableObject(designator) {
   const isObject = typeof designator === "object";
   const className = isObject ? designator.className : designator;
   const serviceName = isObject && designator.scriptName !== void 0 ? getUserServiceName(designator.scriptName) : void 0;
+  const enableSql = isObject ? designator.useSQLite : void 0;
   const unsafeUniqueKey = isObject ? designator.unsafeUniqueKey : void 0;
   const unsafePreventEviction = isObject ? designator.unsafePreventEviction : void 0;
-  return { className, serviceName, unsafeUniqueKey, unsafePreventEviction };
+  return {
+    className,
+    serviceName,
+    enableSql,
+    unsafeUniqueKey,
+    unsafePreventEviction
+  };
 }
 var DURABLE_OBJECTS_PLUGIN_NAME = "do";
 var DURABLE_OBJECTS_STORAGE_SERVICE_NAME = `${DURABLE_OBJECTS_PLUGIN_NAME}:storage`;
@@ -5335,7 +5428,9 @@ var DURABLE_OBJECTS_PLUGIN = {
   },
   getNodeBindings(options) {
     const objects = Object.keys(options.durableObjects ?? {});
-    return Object.fromEntries(objects.map((name) => [name, kProxyNodeBinding]));
+    return Object.fromEntries(
+      objects.map((name) => [name, new ProxyNodeBinding()])
+    );
   },
   async getServices({
     sharedOptions,
@@ -5405,7 +5500,52 @@ var import_url13 = require("url");
 var import_util = require("util");
 var import_acorn = require("acorn");
 var import_acorn_walk = require("acorn-walk");
-var import_zod8 = require("zod");
+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(
@@ -5419,7 +5559,7 @@ function maybeGetStringScriptPathIndex(scriptPath) {
   const match = stringScriptRegexp.exec(scriptPath);
   return match === null ? void 0 : parseInt(match[1]);
 }
-var ModuleRuleTypeSchema = import_zod8.z.enum([
+var ModuleRuleTypeSchema = import_zod9.z.enum([
   "ESModule",
   "CommonJS",
   "NodeJsCompatModule",
@@ -5429,45 +5569,45 @@ var ModuleRuleTypeSchema = import_zod8.z.enum([
   "PythonModule",
   "PythonRequirement"
 ]);
-var ModuleRuleSchema = import_zod8.z.object({
+var ModuleRuleSchema = import_zod9.z.object({
   type: ModuleRuleTypeSchema,
-  include: import_zod8.z.string().array(),
-  fallthrough: import_zod8.z.boolean().optional()
+  include: import_zod9.z.string().array(),
+  fallthrough: import_zod9.z.boolean().optional()
 });
-var ModuleDefinitionSchema = import_zod8.z.object({
+var ModuleDefinitionSchema = import_zod9.z.object({
   type: ModuleRuleTypeSchema,
   path: PathSchema,
-  contents: import_zod8.z.string().or(import_zod8.z.instanceof(Uint8Array)).optional()
+  contents: import_zod9.z.string().or(import_zod9.z.instanceof(Uint8Array)).optional()
 });
-var SourceOptionsSchema = import_zod8.z.union([
-  import_zod8.z.object({
+var SourceOptionsSchema = import_zod9.z.union([
+  import_zod9.z.object({
     // Manually defined modules
     // (used by Wrangler which has its own module collection code)
-    modules: import_zod8.z.array(ModuleDefinitionSchema),
+    modules: import_zod9.z.array(ModuleDefinitionSchema),
     // `modules` "name"s will be their paths relative to this value.
     // This ensures file paths in stack traces are correct.
     modulesRoot: PathSchema.optional()
   }),
-  import_zod8.z.object({
-    script: import_zod8.z.string(),
+  import_zod9.z.object({
+    script: import_zod9.z.string(),
     // Optional script path for resolving modules, and stack traces file names
     scriptPath: PathSchema.optional(),
     // Automatically collect modules by parsing `script` if `true`, or treat as
     // service-worker if `false`
-    modules: import_zod8.z.boolean().optional(),
+    modules: import_zod9.z.boolean().optional(),
     // How to interpret automatically collected modules
-    modulesRules: import_zod8.z.array(ModuleRuleSchema).optional(),
+    modulesRules: import_zod9.z.array(ModuleRuleSchema).optional(),
     // `modules` "name"s will be their paths relative to this value.
     // This ensures file paths in stack traces are correct.
     modulesRoot: PathSchema.optional()
   }),
-  import_zod8.z.object({
+  import_zod9.z.object({
     scriptPath: PathSchema,
     // Automatically collect modules by parsing `scriptPath` if `true`, or treat
     // as service-worker if `false`
-    modules: import_zod8.z.boolean().optional(),
+    modules: import_zod9.z.boolean().optional(),
     // How to interpret automatically collected modules
-    modulesRules: import_zod8.z.array(ModuleRuleSchema).optional(),
+    modulesRules: import_zod9.z.array(ModuleRuleSchema).optional(),
     // `modules` "name"s will be their paths relative to this value.
     // This ensures file paths in stack traces are correct.
     modulesRoot: PathSchema.optional()
@@ -5513,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) {
@@ -5605,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) {
@@ -5676,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"
@@ -5758,7 +5908,7 @@ var import_worker_threads = require("worker_threads");
 var import_fs13 = __toESM(require("fs"));
 var import_path16 = __toESM(require("path"));
 var import_url14 = require("url");
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/plugins/core/errors/sourcemap.ts
 var import_assert6 = __toESM(require("assert"));
@@ -5932,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;
@@ -5948,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) {
@@ -5988,11 +6138,11 @@ function getSourceMappedStack(workerSrcOpts, error) {
   }
   return getSourceMapper()(retrieveSourceMap, error);
 }
-var JsonErrorSchema = import_zod9.z.lazy(
-  () => import_zod9.z.object({
-    message: import_zod9.z.string().optional(),
-    name: import_zod9.z.string().optional(),
-    stack: import_zod9.z.string().optional(),
+var JsonErrorSchema = import_zod10.z.lazy(
+  () => import_zod10.z.object({
+    message: import_zod10.z.string().optional(),
+    name: import_zod10.z.string().optional(),
+    stack: import_zod10.z.string().optional(),
     cause: JsonErrorSchema.optional()
   })
 );
@@ -6133,7 +6283,7 @@ var SynchronousFetcher = class {
       transferList: [this.#channel.port2]
     });
   }
-  fetch(url17, init2) {
+  fetch(url18, init2) {
     this.#ensureWorker();
     Atomics.store(
       this.#notifyHandle,
@@ -6146,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
     });
@@ -6266,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);
   }
@@ -6670,73 +6820,73 @@ var ProxyStubHandler = class extends Function {
 };
 
 // src/plugins/core/services.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var kCurrentWorker = Symbol.for("miniflare.kCurrentWorker");
-var HttpOptionsHeaderSchema = import_zod10.z.object({
-  name: import_zod10.z.string(),
+var HttpOptionsHeaderSchema = import_zod11.z.object({
+  name: import_zod11.z.string(),
   // name should be required
-  value: import_zod10.z.ostring()
+  value: import_zod11.z.ostring()
   // If omitted, the header will be removed
 });
-var HttpOptionsSchema = import_zod10.z.object({
-  style: import_zod10.z.nativeEnum(import_workerd_capnp.HttpOptions_Style).optional(),
-  forwardedProtoHeader: import_zod10.z.ostring(),
-  cfBlobHeader: import_zod10.z.ostring(),
+var HttpOptionsSchema = import_zod11.z.object({
+  style: import_zod11.z.nativeEnum(import_workerd_capnp.HttpOptions_Style).optional(),
+  forwardedProtoHeader: import_zod11.z.ostring(),
+  cfBlobHeader: import_zod11.z.ostring(),
   injectRequestHeaders: HttpOptionsHeaderSchema.array().optional(),
   injectResponseHeaders: HttpOptionsHeaderSchema.array().optional()
 }).transform((options) => ({
   ...options,
   capnpConnectHost: HOST_CAPNP_CONNECT
 }));
-var TlsOptionsKeypairSchema = import_zod10.z.object({
-  privateKey: import_zod10.z.ostring(),
-  certificateChain: import_zod10.z.ostring()
+var TlsOptionsKeypairSchema = import_zod11.z.object({
+  privateKey: import_zod11.z.ostring(),
+  certificateChain: import_zod11.z.ostring()
 });
-var TlsOptionsSchema = import_zod10.z.object({
+var TlsOptionsSchema = import_zod11.z.object({
   keypair: TlsOptionsKeypairSchema.optional(),
-  requireClientCerts: import_zod10.z.oboolean(),
-  trustBrowserCas: import_zod10.z.oboolean(),
-  trustedCertificates: import_zod10.z.string().array().optional(),
-  minVersion: import_zod10.z.nativeEnum(import_workerd_capnp.TlsOptions_Version).optional(),
-  cipherList: import_zod10.z.ostring()
+  requireClientCerts: import_zod11.z.oboolean(),
+  trustBrowserCas: import_zod11.z.oboolean(),
+  trustedCertificates: import_zod11.z.string().array().optional(),
+  minVersion: import_zod11.z.nativeEnum(import_workerd_capnp.TlsOptions_Version).optional(),
+  cipherList: import_zod11.z.ostring()
 });
-var NetworkSchema = import_zod10.z.object({
-  allow: import_zod10.z.string().array().optional(),
-  deny: import_zod10.z.string().array().optional(),
+var NetworkSchema = import_zod11.z.object({
+  allow: import_zod11.z.string().array().optional(),
+  deny: import_zod11.z.string().array().optional(),
   tlsOptions: TlsOptionsSchema.optional()
 });
-var ExternalServerSchema = import_zod10.z.intersection(
-  import_zod10.z.object({ address: import_zod10.z.string() }),
+var ExternalServerSchema = import_zod11.z.intersection(
+  import_zod11.z.object({ address: import_zod11.z.string() }),
   // address should be required
-  import_zod10.z.union([
-    import_zod10.z.object({ http: import_zod10.z.optional(HttpOptionsSchema) }),
-    import_zod10.z.object({
-      https: import_zod10.z.optional(
-        import_zod10.z.object({
+  import_zod11.z.union([
+    import_zod11.z.object({ http: import_zod11.z.optional(HttpOptionsSchema) }),
+    import_zod11.z.object({
+      https: import_zod11.z.optional(
+        import_zod11.z.object({
           options: HttpOptionsSchema.optional(),
           tlsOptions: TlsOptionsSchema.optional(),
-          certificateHost: import_zod10.z.ostring()
+          certificateHost: import_zod11.z.ostring()
         })
       )
     })
   ])
 );
-var DiskDirectorySchema = import_zod10.z.object({
-  path: import_zod10.z.string(),
+var DiskDirectorySchema = import_zod11.z.object({
+  path: import_zod11.z.string(),
   // path should be required
-  writable: import_zod10.z.oboolean()
+  writable: import_zod11.z.oboolean()
 });
-var ServiceFetchSchema = import_zod10.z.custom((v) => typeof v === "function");
-var ServiceDesignatorSchema = import_zod10.z.union([
-  import_zod10.z.string(),
-  import_zod10.z.literal(kCurrentWorker),
-  import_zod10.z.object({
-    name: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.literal(kCurrentWorker)]),
-    entrypoint: import_zod10.z.ostring()
+var ServiceFetchSchema = import_zod11.z.custom((v) => typeof v === "function");
+var ServiceDesignatorSchema = import_zod11.z.union([
+  import_zod11.z.string(),
+  import_zod11.z.literal(kCurrentWorker),
+  import_zod11.z.object({
+    name: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.literal(kCurrentWorker)]),
+    entrypoint: import_zod11.z.ostring()
   }),
-  import_zod10.z.object({ network: NetworkSchema }),
-  import_zod10.z.object({ external: ExternalServerSchema }),
-  import_zod10.z.object({ disk: DiskDirectorySchema }),
+  import_zod11.z.object({ network: NetworkSchema }),
+  import_zod11.z.object({ external: ExternalServerSchema }),
+  import_zod11.z.object({ disk: DiskDirectorySchema }),
   ServiceFetchSchema
 ]);
 
@@ -6758,39 +6908,43 @@ var numericCompare = new Intl.Collator(void 0, { numeric: true }).compare;
 function createFetchMock() {
   return new import_undici7.MockAgent();
 }
-var WrappedBindingSchema = import_zod11.z.object({
-  scriptName: import_zod11.z.string(),
-  entrypoint: import_zod11.z.string().optional(),
-  bindings: import_zod11.z.record(JsonSchema).optional()
+var WrappedBindingSchema = import_zod12.z.object({
+  scriptName: import_zod12.z.string(),
+  entrypoint: import_zod12.z.string().optional(),
+  bindings: import_zod12.z.record(JsonSchema).optional()
 });
-var UnusableStringSchema = import_zod11.z.string().transform(() => void 0);
-var UnsafeDirectSocketSchema = import_zod11.z.object({
-  host: import_zod11.z.ostring(),
-  port: import_zod11.z.onumber(),
-  entrypoint: import_zod11.z.ostring(),
-  proxy: import_zod11.z.oboolean()
+var UnusableStringSchema = import_zod12.z.string().transform(() => void 0);
+var UnsafeDirectSocketSchema = import_zod12.z.object({
+  host: import_zod12.z.ostring(),
+  port: import_zod12.z.onumber(),
+  entrypoint: import_zod12.z.ostring(),
+  proxy: import_zod12.z.oboolean()
 });
-var CoreOptionsSchemaInput = import_zod11.z.intersection(
+var CoreOptionsSchemaInput = import_zod12.z.intersection(
   SourceOptionsSchema,
-  import_zod11.z.object({
-    name: import_zod11.z.string().optional(),
+  import_zod12.z.object({
+    name: import_zod12.z.string().optional(),
     rootPath: UnusableStringSchema.optional(),
-    compatibilityDate: import_zod11.z.string().optional(),
-    compatibilityFlags: import_zod11.z.string().array().optional(),
-    routes: import_zod11.z.string().array().optional(),
-    bindings: import_zod11.z.record(JsonSchema).optional(),
-    wasmBindings: import_zod11.z.record(import_zod11.z.union([PathSchema, import_zod11.z.instanceof(Uint8Array)])).optional(),
-    textBlobBindings: import_zod11.z.record(PathSchema).optional(),
-    dataBlobBindings: import_zod11.z.record(import_zod11.z.union([PathSchema, import_zod11.z.instanceof(Uint8Array)])).optional(),
-    serviceBindings: import_zod11.z.record(ServiceDesignatorSchema).optional(),
-    wrappedBindings: import_zod11.z.record(import_zod11.z.union([import_zod11.z.string(), WrappedBindingSchema])).optional(),
+    compatibilityDate: import_zod12.z.string().optional(),
+    compatibilityFlags: import_zod12.z.string().array().optional(),
+    routes: import_zod12.z.string().array().optional(),
+    bindings: import_zod12.z.record(JsonSchema).optional(),
+    wasmBindings: import_zod12.z.record(import_zod12.z.union([PathSchema, import_zod12.z.instanceof(Uint8Array)])).optional(),
+    textBlobBindings: import_zod12.z.record(PathSchema).optional(),
+    dataBlobBindings: import_zod12.z.record(import_zod12.z.union([PathSchema, import_zod12.z.instanceof(Uint8Array)])).optional(),
+    serviceBindings: import_zod12.z.record(ServiceDesignatorSchema).optional(),
+    wrappedBindings: import_zod12.z.record(import_zod12.z.union([import_zod12.z.string(), WrappedBindingSchema])).optional(),
     outboundService: ServiceDesignatorSchema.optional(),
-    fetchMock: import_zod11.z.instanceof(import_undici7.MockAgent).optional(),
+    fetchMock: import_zod12.z.instanceof(import_undici7.MockAgent).optional(),
     // TODO(soon): remove this in favour of per-object `unsafeUniqueKey: kEphemeralUniqueKey`
-    unsafeEphemeralDurableObjects: import_zod11.z.boolean().optional(),
+    unsafeEphemeralDurableObjects: import_zod12.z.boolean().optional(),
     unsafeDirectSockets: UnsafeDirectSocketSchema.array().optional(),
-    unsafeEvalBinding: import_zod11.z.string().optional(),
-    unsafeUseModuleFallbackService: import_zod11.z.boolean().optional()
+    unsafeEvalBinding: import_zod12.z.string().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) => {
@@ -6806,30 +6960,30 @@ var CoreOptionsSchema = CoreOptionsSchemaInput.transform((value) => {
   }
   return value;
 });
-var CoreSharedOptionsSchema = import_zod11.z.object({
+var CoreSharedOptionsSchema = import_zod12.z.object({
   rootPath: UnusableStringSchema.optional(),
-  host: import_zod11.z.string().optional(),
-  port: import_zod11.z.number().optional(),
-  https: import_zod11.z.boolean().optional(),
-  httpsKey: import_zod11.z.string().optional(),
-  httpsKeyPath: import_zod11.z.string().optional(),
-  httpsCert: import_zod11.z.string().optional(),
-  httpsCertPath: import_zod11.z.string().optional(),
-  inspectorPort: import_zod11.z.number().optional(),
-  verbose: import_zod11.z.boolean().optional(),
-  log: import_zod11.z.instanceof(Log).optional(),
-  handleRuntimeStdio: import_zod11.z.function(import_zod11.z.tuple([import_zod11.z.instanceof(import_stream2.Readable), import_zod11.z.instanceof(import_stream2.Readable)])).optional(),
-  upstream: import_zod11.z.string().optional(),
+  host: import_zod12.z.string().optional(),
+  port: import_zod12.z.number().optional(),
+  https: import_zod12.z.boolean().optional(),
+  httpsKey: import_zod12.z.string().optional(),
+  httpsKeyPath: import_zod12.z.string().optional(),
+  httpsCert: import_zod12.z.string().optional(),
+  httpsCertPath: import_zod12.z.string().optional(),
+  inspectorPort: import_zod12.z.number().optional(),
+  verbose: import_zod12.z.boolean().optional(),
+  log: import_zod12.z.instanceof(Log).optional(),
+  handleRuntimeStdio: import_zod12.z.function(import_zod12.z.tuple([import_zod12.z.instanceof(import_stream2.Readable), import_zod12.z.instanceof(import_stream2.Readable)])).optional(),
+  upstream: import_zod12.z.string().optional(),
   // TODO: add back validation of cf object
-  cf: import_zod11.z.union([import_zod11.z.boolean(), import_zod11.z.string(), import_zod11.z.record(import_zod11.z.any())]).optional(),
-  liveReload: import_zod11.z.boolean().optional(),
+  cf: import_zod12.z.union([import_zod12.z.boolean(), import_zod12.z.string(), import_zod12.z.record(import_zod12.z.any())]).optional(),
+  liveReload: import_zod12.z.boolean().optional(),
   // This is a shared secret between a proxy server and miniflare that can be
   // passed in a header to prove that the request came from the proxy and not
   // some malicious attacker.
-  unsafeProxySharedSecret: import_zod11.z.string().optional(),
+  unsafeProxySharedSecret: import_zod12.z.string().optional(),
   unsafeModuleFallbackService: ServiceFetchSchema.optional(),
   // Keep blobs when deleting/overwriting keys, required for stacked storage
-  unsafeStickyBlobs: import_zod11.z.boolean().optional()
+  unsafeStickyBlobs: import_zod12.z.boolean().optional()
 });
 var CORE_PLUGIN_NAME2 = "core";
 var LIVE_RELOAD_SCRIPT_TEMPLATE = (port) => `<script defer type="application/javascript">
@@ -6855,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") {
@@ -6872,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);
   }
@@ -6928,11 +7082,20 @@ function validateCompatibilityDate(log, compatibilityDate) {
   }
   return compatibilityDate;
 }
-function buildJsonBindings(bindings) {
-  return Object.entries(bindings).map(([name, value]) => ({
-    name,
-    json: JSON.stringify(value)
-  }));
+function buildBindings(bindings) {
+  return Object.entries(bindings).map(([name, value]) => {
+    if (typeof value === "string") {
+      return {
+        name,
+        text: value
+      };
+    } else {
+      return {
+        name,
+        json: JSON.stringify(value)
+      };
+    }
+  });
 }
 var WRAPPED_MODULE_PREFIX = "miniflare-internal:wrapped:";
 function workerNameToWrappedModule(workerName) {
@@ -6949,7 +7112,7 @@ var CORE_PLUGIN = {
   getBindings(options, workerIndex) {
     const bindings = [];
     if (options.bindings !== void 0) {
-      bindings.push(...buildJsonBindings(options.bindings));
+      bindings.push(...buildBindings(options.bindings));
     }
     if (options.wasmBindings !== void 0) {
       bindings.push(
@@ -6961,7 +7124,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 }))
         )
       );
     }
@@ -6983,7 +7146,8 @@ var CORE_PLUGIN = {
               workerIndex,
               "#" /* UNKNOWN */,
               name,
-              service
+              service,
+              options.hasAssetsAndIsVitest
             )
           };
         })
@@ -6997,7 +7161,7 @@ var CORE_PLUGIN = {
           const entrypoint = isObject ? designator.entrypoint : void 0;
           const bindings2 = isObject ? designator.bindings : void 0;
           const moduleName2 = workerNameToWrappedModule(scriptName);
-          const innerBindings = bindings2 === void 0 ? [] : buildJsonBindings(bindings2);
+          const innerBindings = bindings2 === void 0 ? [] : buildBindings(bindings2);
           return {
             name,
             wrapped: { moduleName: moduleName2, entrypoint, innerBindings }
@@ -7033,7 +7197,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])
         )
       );
     }
@@ -7048,7 +7212,7 @@ var CORE_PLUGIN = {
       bindingEntries2.push(
         ...Object.keys(options.serviceBindings).map((name) => [
           name,
-          kProxyNodeBinding
+          new ProxyNodeBinding()
         ])
       );
     }
@@ -7056,7 +7220,7 @@ var CORE_PLUGIN = {
       bindingEntries2.push(
         ...Object.keys(options.wrappedBindings).map((name) => [
           name,
-          kProxyNodeBinding
+          new ProxyNodeBinding()
         ])
       );
     }
@@ -7174,16 +7338,21 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
           compatibilityFlags: options.compatibilityFlags,
           bindings: workerBindings,
           durableObjectNamespaces: classNamesEntries.map(
-            ([className, { unsafeUniqueKey, unsafePreventEviction }]) => {
+            ([
+              className,
+              { enableSql, unsafeUniqueKey, unsafePreventEviction }
+            ]) => {
               if (unsafeUniqueKey === kUnsafeEphemeralUniqueKey) {
                 return {
                   className,
+                  enableSql,
                   ephemeralLocal: kVoid,
                   preventEviction: unsafePreventEviction
                 };
               } else {
                 return {
                   className,
+                  enableSql,
                   // This `uniqueKey` will (among other things) be used as part of the
                   // path when persisting to the file-system. `-` is invalid in
                   // JavaScript class names, but safe on filesystems (incl. Windows).
@@ -7200,7 +7369,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
@@ -7363,6 +7533,7 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
       modulesRoot,
       additionalModuleNames,
       options.modulesRules,
+      options.compatibilityDate,
       options.compatibilityFlags
     );
     locator.visitEntrypoint(code, scriptPath);
@@ -7373,23 +7544,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_zod12 = require("zod");
-var RoutingConfigSchema = import_zod12.z.object({
-  hasUserWorker: import_zod12.z.boolean()
-});
-var AssetsOptionsSchema = import_zod12.z.object({
-  assets: import_zod12.z.object({
-    workerName: import_zod12.z.string().optional(),
-    path: PathSchema,
-    bindingName: import_zod12.z.string().optional(),
-    routingConfig: RoutingConfigSchema
+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(),
+    directory: PathSchema,
+    binding: import_zod13.z.string().optional(),
+    routingConfig: RoutingConfigSchema.optional(),
+    assetConfig: AssetConfigSchema.optional()
   }).optional()
 });
 
@@ -7397,35 +7562,37 @@ var AssetsOptionsSchema = import_zod12.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]: kProxyNodeBinding
+      [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: {
@@ -7444,12 +7611,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: {
@@ -7467,7 +7633,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_MANIFEST",
-            data: assetsManifest
+            data: encodedAssetManifest
+          },
+          {
+            name: "CONFIG",
+            json: JSON.stringify(options.assets.assetConfig ?? {})
           }
         ]
       }
@@ -7501,40 +7671,25 @@ var ASSETS_PLUGIN = {
     return [storageService, namespaceService, assetService, routerService];
   }
 };
-var MAX_ASSET_COUNT = 2e4;
-var MAX_ASSET_SIZE = 25 * 1024 * 1024;
-var MANIFEST_HEADER_SIZE = 20;
-var PATH_HASH_OFFSET = 0;
-var PATH_HASH_SIZE = 16;
-var CONTENT_HASH_OFFSET = PATH_HASH_SIZE;
-var CONTENT_HASH_SIZE = 16;
-var TAIL_RESERVED_SIZE = 8;
-var ENTRY_SIZE = PATH_HASH_SIZE + CONTENT_HASH_SIZE + TAIL_RESERVED_SIZE;
-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;
       } else {
-        if (counter >= MAX_ASSET_COUNT) {
-          throw new Error(
-            `Maximum number of assets exceeded.
-Cloudflare Workers supports up to ${MAX_ASSET_COUNT.toLocaleString()} assets in a version. We found ${counter.toLocaleString()} files in the specified assets directory "${dir}".
-Ensure your assets directory contains a maximum of ${MAX_ASSET_COUNT.toLocaleString()} files, and that you have specified your assets directory correctly.`
-          );
-        }
         if (filestat.size > MAX_ASSET_SIZE) {
           throw new Error(
             `Asset too large.
@@ -7552,38 +7707,47 @@ 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)));
+        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++;
       }
     })
   );
-  return manifest;
-};
-var hashPath = async (path27) => {
-  const encoder3 = new TextEncoder();
-  const data = encoder3.encode(path27);
-  const hashBuffer = await import_node_crypto.default.subtle.digest("SHA-256", data.buffer);
-  return new Uint8Array(hashBuffer, 0, PATH_HASH_SIZE);
-};
-var encodeFilePath = (filePath) => {
-  const encodedPath = filePath.split(import_node_path.default.sep).map((segment) => encodeURIComponent(segment)).join("/");
-  return "/" + encodedPath;
+  if (counter > MAX_ASSET_COUNT) {
+    throw new Error(
+      `Maximum number of assets exceeded.
+Cloudflare Workers supports up to ${MAX_ASSET_COUNT.toLocaleString()} assets in a version. We found ${counter.toLocaleString()} files in the specified assets directory "${dir}".
+Ensure your assets directory contains a maximum of ${MAX_ASSET_COUNT.toLocaleString()} files, and that you have specified your assets directory correctly.`
+    );
+  }
+  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;
     }
   }
@@ -7591,41 +7755,27 @@ var comparisonFn = (a, b) => {
 };
 var encodeManifest = (manifest) => {
   const assetManifestBytes = new Uint8Array(
-    MANIFEST_HEADER_SIZE + manifest.length * ENTRY_SIZE
+    HEADER_SIZE + manifest.length * ENTRY_SIZE
   );
   for (const [i, entry] of manifest.entries()) {
-    const entryOffset = MANIFEST_HEADER_SIZE + i * ENTRY_SIZE;
-    assetManifestBytes.set(entry, entryOffset + PATH_HASH_OFFSET);
-    assetManifestBytes.set(entry, entryOffset + CONTENT_HASH_OFFSET);
+    const entryOffset = HEADER_SIZE + i * ENTRY_SIZE;
+    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))
-        );
-        assetsReverseMap[pathHash] = {
-          filePath: relativeFilepath,
-          contentType: (0, import_mime.getType)(filepath) ?? "application/octet-stream"
-        };
-      }
-    })
-  );
-  return JSON.stringify(assetsReverseMap);
-};
 var bytesToHex = (buffer) => {
   return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
 };
+var hashPath = async (path28) => {
+  const encoder3 = new TextEncoder();
+  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);
+};
 
 // src/plugins/d1/index.ts
 var import_promises8 = __toESM(require("fs/promises"));
@@ -7644,11 +7794,11 @@ function database_worker_default() {
 }
 
 // src/plugins/d1/index.ts
-var import_zod13 = require("zod");
-var D1OptionsSchema = import_zod13.z.object({
-  d1Databases: import_zod13.z.union([import_zod13.z.record(import_zod13.z.string()), import_zod13.z.string().array()]).optional()
+var import_zod14 = require("zod");
+var D1OptionsSchema = import_zod14.z.object({
+  d1Databases: import_zod14.z.union([import_zod14.z.record(import_zod14.z.string()), import_zod14.z.string().array()]).optional()
 });
-var D1SharedOptionsSchema = import_zod13.z.object({
+var D1SharedOptionsSchema = import_zod14.z.object({
   d1Persist: PersistenceSchema
 });
 var D1_PLUGIN_NAME = "d1";
@@ -7690,7 +7840,7 @@ var D1_PLUGIN = {
   getNodeBindings(options) {
     const databases = namespaceKeys(options.d1Databases);
     return Object.fromEntries(
-      databases.map((name) => [name, kProxyNodeBinding])
+      databases.map((name) => [name, new ProxyNodeBinding()])
     );
   },
   async getServices({
@@ -7761,68 +7911,68 @@ var D1_PLUGIN = {
 
 // src/plugins/hyperdrive/index.ts
 var import_node_assert3 = __toESM(require("node:assert"));
-var import_zod14 = require("zod");
+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_zod14.z.union([import_zod14.z.string().url(), import_zod14.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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.ZodIssueCode.custom,
+      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_zod14.z.object({
-  hyperdrives: import_zod14.z.record(import_zod14.z.string(), HyperdriveSchema).optional()
+var HyperdriveInputOptionsSchema = import_zod15.z.object({
+  hyperdrives: import_zod15.z.record(import_zod15.z.string(), HyperdriveSchema).optional()
 });
 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: {
@@ -7830,23 +7980,37 @@ 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
           }
         };
       }
     );
   },
-  getNodeBindings() {
-    return {};
+  getNodeBindings(options) {
+    return Object.fromEntries(
+      Object.entries(options.hyperdrives ?? {}).map(([name, url18]) => {
+        const connectionOverrides = {
+          connectionString: `${url18}`,
+          port: Number.parseInt(url18.port),
+          host: url18.hostname
+        };
+        const proxyNodeBinding = new ProxyNodeBinding({
+          get(target, prop) {
+            return prop in connectionOverrides ? connectionOverrides[prop] : target[prop];
+          }
+        });
+        return [name, proxyNodeBinding];
+      })
+    );
   },
   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: {}
         }
       })
@@ -7871,7 +8035,7 @@ function namespace_worker_default() {
 }
 
 // src/plugins/kv/index.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/plugins/kv/constants.ts
 var KV_PLUGIN_NAME = "kv";
@@ -7950,7 +8114,7 @@ async function getSitesNodeBindings(options) {
     siteRegExps
   );
   return {
-    [SiteBindings.KV_NAMESPACE_SITE]: kProxyNodeBinding,
+    [SiteBindings.KV_NAMESPACE_SITE]: new ProxyNodeBinding(),
     [SiteBindings.JSON_SITE_MANIFEST]: __STATIC_CONTENT_MANIFEST
   };
 }
@@ -7991,14 +8155,14 @@ function getSitesServices(options) {
 }
 
 // src/plugins/kv/index.ts
-var KVOptionsSchema = import_zod15.z.object({
-  kvNamespaces: import_zod15.z.union([import_zod15.z.record(import_zod15.z.string()), import_zod15.z.string().array()]).optional(),
+var KVOptionsSchema = import_zod16.z.object({
+  kvNamespaces: import_zod16.z.union([import_zod16.z.record(import_zod16.z.string()), import_zod16.z.string().array()]).optional(),
   // Workers Sites
   sitePath: PathSchema.optional(),
-  siteInclude: import_zod15.z.string().array().optional(),
-  siteExclude: import_zod15.z.string().array().optional()
+  siteInclude: import_zod16.z.string().array().optional(),
+  siteExclude: import_zod16.z.string().array().optional()
 });
-var KVSharedOptionsSchema = import_zod15.z.object({
+var KVSharedOptionsSchema = import_zod16.z.object({
   kvPersist: PersistenceSchema
 });
 var SERVICE_NAMESPACE_PREFIX = `${KV_PLUGIN_NAME}:ns`;
@@ -8028,7 +8192,7 @@ var KV_PLUGIN = {
   async getNodeBindings(options) {
     const namespaces = namespaceKeys(options.kvNamespaces);
     const bindings = Object.fromEntries(
-      namespaces.map((name) => [name, kProxyNodeBinding])
+      namespaces.map((name) => [name, new ProxyNodeBinding()])
     );
     if (isWorkersSitesEnabled(options)) {
       Object.assign(bindings, await getSitesNodeBindings(options));
@@ -8115,20 +8279,20 @@ function broker_worker_default() {
 }
 
 // src/plugins/queues/index.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/plugins/queues/errors.ts
 var QueuesError = class extends MiniflareError {
 };
 
 // src/plugins/queues/index.ts
-var QueuesOptionsSchema = import_zod16.z.object({
-  queueProducers: import_zod16.z.union([
-    import_zod16.z.record(QueueProducerOptionsSchema),
-    import_zod16.z.string().array(),
-    import_zod16.z.record(import_zod16.z.string())
+var QueuesOptionsSchema = import_zod17.z.object({
+  queueProducers: import_zod17.z.union([
+    import_zod17.z.record(QueueProducerOptionsSchema),
+    import_zod17.z.string().array(),
+    import_zod17.z.record(import_zod17.z.string())
   ]).optional(),
-  queueConsumers: import_zod16.z.union([import_zod16.z.record(QueueConsumerOptionsSchema), import_zod16.z.string().array()]).optional()
+  queueConsumers: import_zod17.z.union([import_zod17.z.record(QueueConsumerOptionsSchema), import_zod17.z.string().array()]).optional()
 });
 var QUEUES_PLUGIN_NAME = "queues";
 var SERVICE_QUEUE_PREFIX = `${QUEUES_PLUGIN_NAME}:queue`;
@@ -8148,7 +8312,9 @@ var QUEUES_PLUGIN = {
   },
   getNodeBindings(options) {
     const queues = bindingKeys(options.queueProducers);
-    return Object.fromEntries(queues.map((name) => [name, kProxyNodeBinding]));
+    return Object.fromEntries(
+      queues.map((name) => [name, new ProxyNodeBinding()])
+    );
   },
   async getServices({
     options,
@@ -8178,7 +8344,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 },
@@ -8252,11 +8422,11 @@ function bucket_worker_default() {
 }
 
 // src/plugins/r2/index.ts
-var import_zod17 = require("zod");
-var R2OptionsSchema = import_zod17.z.object({
-  r2Buckets: import_zod17.z.union([import_zod17.z.record(import_zod17.z.string()), import_zod17.z.string().array()]).optional()
+var import_zod18 = require("zod");
+var R2OptionsSchema = import_zod18.z.object({
+  r2Buckets: import_zod18.z.union([import_zod18.z.record(import_zod18.z.string()), import_zod18.z.string().array()]).optional()
 });
-var R2SharedOptionsSchema = import_zod17.z.object({
+var R2SharedOptionsSchema = import_zod18.z.object({
   r2Persist: PersistenceSchema
 });
 var R2_PLUGIN_NAME = "r2";
@@ -8279,7 +8449,9 @@ var R2_PLUGIN = {
   },
   getNodeBindings(options) {
     const buckets = namespaceKeys(options.r2Buckets);
-    return Object.fromEntries(buckets.map((name) => [name, kProxyNodeBinding]));
+    return Object.fromEntries(
+      buckets.map((name) => [name, new ProxyNodeBinding()])
+    );
   },
   async getServices({
     options,
@@ -8361,26 +8533,26 @@ function ratelimit_worker_default() {
 }
 
 // src/plugins/ratelimit/index.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var PeriodType = /* @__PURE__ */ ((PeriodType2) => {
   PeriodType2[PeriodType2["TENSECONDS"] = 10] = "TENSECONDS";
   PeriodType2[PeriodType2["MINUTE"] = 60] = "MINUTE";
   return PeriodType2;
 })(PeriodType || {});
-var RatelimitConfigSchema = import_zod18.z.object({
-  simple: import_zod18.z.object({
-    limit: import_zod18.z.number().gt(0),
+var RatelimitConfigSchema = import_zod19.z.object({
+  simple: import_zod19.z.object({
+    limit: import_zod19.z.number().gt(0),
     // may relax this to be any number in the future
-    period: import_zod18.z.nativeEnum(PeriodType).optional()
+    period: import_zod19.z.nativeEnum(PeriodType).optional()
   })
 });
-var RatelimitOptionsSchema = import_zod18.z.object({
-  ratelimits: import_zod18.z.record(RatelimitConfigSchema).optional()
+var RatelimitOptionsSchema = import_zod19.z.object({
+  ratelimits: import_zod19.z.record(RatelimitConfigSchema).optional()
 });
 var RATELIMIT_PLUGIN_NAME = "ratelimit";
 var SERVICE_RATELIMIT_PREFIX = `${RATELIMIT_PLUGIN_NAME}`;
 var SERVICE_RATELIMIT_MODULE = `cloudflare-internal:${SERVICE_RATELIMIT_PREFIX}:module`;
-function buildJsonBindings2(bindings) {
+function buildJsonBindings(bindings) {
   return Object.entries(bindings).map(([name, value]) => ({
     name,
     json: JSON.stringify(value)
@@ -8397,7 +8569,7 @@ var RATELIMIT_PLUGIN = {
         name,
         wrapped: {
           moduleName: SERVICE_RATELIMIT_MODULE,
-          innerBindings: buildJsonBindings2({
+          innerBindings: buildJsonBindings({
             namespaceId: name,
             limit: config.simple.limit,
             period: config.simple.period
@@ -8412,7 +8584,10 @@ var RATELIMIT_PLUGIN = {
       return {};
     }
     return Object.fromEntries(
-      Object.keys(options.ratelimits).map((name) => [name, kProxyNodeBinding])
+      Object.keys(options.ratelimits).map((name) => [
+        name,
+        new ProxyNodeBinding()
+      ])
     );
   },
   async getServices({ options }) {
@@ -8436,6 +8611,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,
@@ -8447,7 +8741,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);
 
@@ -8553,8 +8848,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;
@@ -8601,7 +8896,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)) {
@@ -8811,7 +9106,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) {
@@ -8827,7 +9122,7 @@ function validateOptions(opts) {
       }
     }
   } catch (e) {
-    if (e instanceof import_zod20.z.ZodError) {
+    if (e instanceof import_zod22.z.ZodError) {
       let formatted;
       try {
         formatted = formatZodError(e, opts);
@@ -8897,6 +9192,7 @@ function getDurableObjectClassNames(allWorkerOpts) {
         className,
         // Fallback to current worker service if name not defined
         serviceName = workerServiceName,
+        enableSql,
         unsafeUniqueKey,
         unsafePreventEviction
       } = normaliseDurableObject(designator);
@@ -8907,6 +9203,14 @@ function getDurableObjectClassNames(allWorkerOpts) {
       }
       if (classNames.has(className)) {
         const existingInfo = classNames.get(className);
+        if (existingInfo?.enableSql !== enableSql) {
+          throw new MiniflareCoreError(
+            "ERR_DIFFERENT_STORAGE_BACKEND",
+            `Different storage backends defined for Durable Object "${className}" in "${serviceName}": ${JSON.stringify(
+              enableSql
+            )} and ${JSON.stringify(existingInfo?.enableSql)}`
+          );
+        }
         if (existingInfo?.unsafeUniqueKey !== unsafeUniqueKey) {
           throw new MiniflareCoreError(
             "ERR_DIFFERENT_UNIQUE_KEYS",
@@ -8924,7 +9228,11 @@ function getDurableObjectClassNames(allWorkerOpts) {
           );
         }
       } else {
-        classNames.set(className, { unsafeUniqueKey, unsafePreventEviction });
+        classNames.set(className, {
+          enableSql,
+          unsafeUniqueKey,
+          unsafePreventEviction
+        });
       }
     }
   }
@@ -8978,8 +9286,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 });
+        }
       }
     }
   }
@@ -9219,7 +9534,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")}`
     );
@@ -9227,7 +9542,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)}`);
       }
@@ -9260,8 +9575,11 @@ var Miniflare2 = class {
     }
     (0, import_assert12.default)(typeof service === "function");
     try {
-      const response = await service(request, this);
-      return import_zod20.z.instanceof(Response).parse(response);
+      let response = await service(request, this);
+      if (!(response instanceof Response)) {
+        response = new Response(response.body, response);
+      }
+      return import_zod22.z.instanceof(Response).parse(response);
     } catch (e) {
       return new Response(e?.stack ?? e, { status: 500 });
     }
@@ -9286,11 +9604,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,
@@ -9311,13 +9629,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 */,
@@ -9452,18 +9770,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 = [];
@@ -9578,8 +9904,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
@@ -9793,11 +10122,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");
     }
@@ -9811,7 +10140,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());
@@ -9864,13 +10193,16 @@ var Miniflare2 = class {
     for (const [key, plugin] of PLUGIN_ENTRIES) {
       const pluginBindings = await plugin.getNodeBindings(workerOpts[key]);
       for (const [name, binding] of Object.entries(pluginBindings)) {
-        if (binding === kProxyNodeBinding) {
+        if (binding instanceof ProxyNodeBinding) {
           const proxyBindingName = getProxyBindingName(key, workerName, name);
-          const proxy = proxyClient.env[proxyBindingName];
+          let proxy = proxyClient.env[proxyBindingName];
           (0, import_assert12.default)(
             proxy !== void 0,
             `Expected ${proxyBindingName} to be bound`
           );
+          if (binding.proxyOverrideHandler) {
+            proxy = new Proxy(proxy, binding.proxyOverrideHandler);
+          }
           bindings[name] = proxy;
         } else {
           bindings[name] = binding;
@@ -9958,7 +10290,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);
     }
   }
@@ -9992,7 +10324,6 @@ var Miniflare2 = class {
   DispatchFetchDispatcher,
   DurableObjectsOptionsSchema,
   DurableObjectsSharedOptionsSchema,
-  ENTRY_SOCKET_HTTP_OPTIONS,
   ErrorEvent,
   File,
   FormData,
@@ -10030,6 +10361,7 @@ var Miniflare2 = class {
   PersistenceSchema,
   ProxyAddresses,
   ProxyClient,
+  ProxyNodeBinding,
   ProxyOps,
   QUEUES_PLUGIN,
   QUEUES_PLUGIN_NAME,
@@ -10057,7 +10389,6 @@ var Miniflare2 = class {
   Request,
   Response,
   RouterError,
-  RoutingConfigSchema,
   Runtime,
   SERVICE_ENTRY,
   SERVICE_LOOPBACK,
@@ -10071,10 +10402,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,
@@ -10083,7 +10419,7 @@ var Miniflare2 = class {
   _transformsForContentEncodingAndContentType,
   base64Decode,
   base64Encode,
-  buildAssetsManifest,
+  buildAssetManifest,
   compileModuleRules,
   coupleWebSocket,
   createFetchMock,
@@ -10103,6 +10439,7 @@ var Miniflare2 = class {
   getFreshSourceMapSupport,
   getGlobalServices,
   getMiniflareObjectBindings,
+  getNodeCompat,
   getPersistPath,
   getRootPath,
   globsToRegExps,
@@ -10111,7 +10448,6 @@ var Miniflare2 = class {
   isSitesRequest,
   kCurrentWorker,
   kInspectorSocket,
-  kProxyNodeBinding,
   kUnsafeEphemeralUniqueKey,
   kVoid,
   matchRoutes,