miniflare 0.0.0-e8975a93a → 0.0.0-eaf71b86c

package/dist/src/index.js

@@ -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();
       }
@@ -2470,6 +2494,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 +2522,6 @@ __export(src_exports, {
   Request: () => Request,
   Response: () => Response,
   RouterError: () => RouterError,
-  RoutingConfigSchema: () => RoutingConfigSchema,
   Runtime: () => Runtime,
   SERVICE_ENTRY: () => SERVICE_ENTRY,
   SERVICE_LOOPBACK: () => SERVICE_LOOPBACK,
@@ -2523,7 +2547,7 @@ __export(src_exports, {
   _transformsForContentEncodingAndContentType: () => _transformsForContentEncodingAndContentType,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
-  buildAssetsManifest: () => buildAssetsManifest,
+  buildAssetManifest: () => buildAssetManifest,
   compileModuleRules: () => compileModuleRules,
   coupleWebSocket: () => coupleWebSocket,
   createFetchMock: () => createFetchMock,
@@ -2543,6 +2567,7 @@ __export(src_exports, {
   getFreshSourceMapSupport: () => getFreshSourceMapSupport,
   getGlobalServices: () => getGlobalServices,
   getMiniflareObjectBindings: () => getMiniflareObjectBindings,
+  getNodeCompat: () => getNodeCompat,
   getPersistPath: () => getPersistPath,
   getRootPath: () => getRootPath,
   globsToRegExps: () => globsToRegExps,
@@ -2551,7 +2576,6 @@ __export(src_exports, {
   isSitesRequest: () => isSitesRequest,
   kCurrentWorker: () => kCurrentWorker,
   kInspectorSocket: () => kInspectorSocket,
-  kProxyNodeBinding: () => kProxyNodeBinding,
   kUnsafeEphemeralUniqueKey: () => kUnsafeEphemeralUniqueKey,
   kVoid: () => kVoid,
   matchRoutes: () => matchRoutes,
@@ -2679,7 +2703,7 @@ function zod_worker_default() {
 
 // src/index.ts
 var import_ws3 = require("ws");
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/cf.ts
 var import_assert = __toESM(require("assert"));
@@ -4564,8 +4588,50 @@ 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()
+});
+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()
+});
+
+// ../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
 var BYTE_UNITS = [
@@ -4723,7 +4789,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 +4798,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 +4846,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 +4949,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 +4998,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 +5006,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"));
@@ -5079,8 +5151,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;
@@ -5164,11 +5240,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 +5363,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 +5419,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 +5491,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 +5550,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 +5560,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 +5644,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 +5739,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) {
@@ -5758,7 +5899,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"));
@@ -5988,11 +6129,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()
   })
 );
@@ -6670,73 +6811,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 +6899,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 +6951,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 +7000,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 +7017,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);
   }
@@ -6983,7 +7128,8 @@ var CORE_PLUGIN = {
               workerIndex,
               "#" /* UNKNOWN */,
               name,
-              service
+              service,
+              options.hasAssetsAndIsVitest
             )
           };
         })
@@ -7048,7 +7194,7 @@ var CORE_PLUGIN = {
       bindingEntries2.push(
         ...Object.keys(options.serviceBindings).map((name) => [
           name,
-          kProxyNodeBinding
+          new ProxyNodeBinding()
         ])
       );
     }
@@ -7056,7 +7202,7 @@ var CORE_PLUGIN = {
       bindingEntries2.push(
         ...Object.keys(options.wrappedBindings).map((name) => [
           name,
-          kProxyNodeBinding
+          new ProxyNodeBinding()
         ])
       );
     }
@@ -7174,16 +7320,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 +7351,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 +7515,7 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
       modulesRoot,
       additionalModuleNames,
       options.modulesRules,
+      options.compatibilityDate,
       options.compatibilityFlags
     );
     locator.visitEntrypoint(code, scriptPath);
@@ -7373,23 +7526,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 +7544,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 +7593,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 +7615,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_MANIFEST",
-            data: assetsManifest
+            data: encodedAssetManifest
+          },
+          {
+            name: "CONFIG",
+            json: JSON.stringify(options.assets.assetConfig ?? {})
           }
         ]
       }
@@ -7501,40 +7653,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 +7689,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 +7737,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 (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);
+};
 
 // src/plugins/d1/index.ts
 var import_promises8 = __toESM(require("fs/promises"));
@@ -7644,11 +7776,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 +7822,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,7 +7893,7 @@ 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:";
@@ -7773,48 +7905,48 @@ function getPort(url17) {
     return "5432";
   import_node_assert3.default.fail(`Expected known protocol, got ${url17.protocol}`);
 }
-var HyperdriveSchema = import_zod14.z.union([import_zod14.z.string().url(), import_zod14.z.instanceof(URL)]).transform((url17, ctx) => {
+var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url17, ctx) => {
   if (typeof url17 === "string")
     url17 = new URL(url17);
   if (url17.protocol === "") {
     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)) {
     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 === "") {
     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 === "") {
     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 === "") {
     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 === "") {
     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;
 });
-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,
@@ -7838,8 +7970,22 @@ var HYPERDRIVE_PLUGIN = {
       }
     );
   },
-  getNodeBindings() {
-    return {};
+  getNodeBindings(options) {
+    return Object.fromEntries(
+      Object.entries(options.hyperdrives ?? {}).map(([name, url17]) => {
+        const connectionOverrides = {
+          connectionString: `${url17}`,
+          port: Number.parseInt(url17.port),
+          host: url17.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(
@@ -7871,7 +8017,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 +8096,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 +8137,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 +8174,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 +8261,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 +8294,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,
@@ -8252,11 +8400,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 +8427,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,21 +8511,21 @@ 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}`;
@@ -8412,7 +8562,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 }) {
@@ -8827,7 +8980,7 @@ function validateOptions(opts) {
       }
     }
   } catch (e) {
-    if (e instanceof import_zod20.z.ZodError) {
+    if (e instanceof import_zod21.z.ZodError) {
       let formatted;
       try {
         formatted = formatZodError(e, opts);
@@ -8897,6 +9050,7 @@ function getDurableObjectClassNames(allWorkerOpts) {
         className,
         // Fallback to current worker service if name not defined
         serviceName = workerServiceName,
+        enableSql,
         unsafeUniqueKey,
         unsafePreventEviction
       } = normaliseDurableObject(designator);
@@ -8907,6 +9061,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 +9086,11 @@ function getDurableObjectClassNames(allWorkerOpts) {
           );
         }
       } else {
-        classNames.set(className, { unsafeUniqueKey, unsafePreventEviction });
+        classNames.set(className, {
+          enableSql,
+          unsafeUniqueKey,
+          unsafePreventEviction
+        });
       }
     }
   }
@@ -8978,8 +9144,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 });
+        }
       }
     }
   }
@@ -9260,8 +9433,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_zod21.z.instanceof(Response).parse(response);
     } catch (e) {
       return new Response(e?.stack ?? e, { status: 500 });
     }
@@ -9459,6 +9635,9 @@ var Miniflare2 = class {
     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];
@@ -9578,8 +9757,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
@@ -9864,13 +10046,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;
@@ -10030,6 +10215,7 @@ var Miniflare2 = class {
   PersistenceSchema,
   ProxyAddresses,
   ProxyClient,
+  ProxyNodeBinding,
   ProxyOps,
   QUEUES_PLUGIN,
   QUEUES_PLUGIN_NAME,
@@ -10057,7 +10243,6 @@ var Miniflare2 = class {
   Request,
   Response,
   RouterError,
-  RoutingConfigSchema,
   Runtime,
   SERVICE_ENTRY,
   SERVICE_LOOPBACK,
@@ -10083,7 +10268,7 @@ var Miniflare2 = class {
   _transformsForContentEncodingAndContentType,
   base64Decode,
   base64Encode,
-  buildAssetsManifest,
+  buildAssetManifest,
   compileModuleRules,
   coupleWebSocket,
   createFetchMock,
@@ -10103,6 +10288,7 @@ var Miniflare2 = class {
   getFreshSourceMapSupport,
   getGlobalServices,
   getMiniflareObjectBindings,
+  getNodeCompat,
   getPersistPath,
   getRootPath,
   globsToRegExps,
@@ -10111,7 +10297,6 @@ var Miniflare2 = class {
   isSitesRequest,
   kCurrentWorker,
   kInspectorSocket,
-  kProxyNodeBinding,
   kUnsafeEphemeralUniqueKey,
   kVoid,
   matchRoutes,