miniflare 0.0.0-ecef68635 → 0.0.0-ee305dd67

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;
     };
@@ -2535,10 +2535,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,
@@ -2612,11 +2617,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"));
@@ -2703,7 +2708,7 @@ function zod_worker_default() {
 
 // src/index.ts
 var import_ws3 = require("ws");
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/cf.ts
 var import_assert = __toESM(require("assert"));
@@ -3311,12 +3316,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,
@@ -3445,23 +3450,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;
@@ -3706,8 +3711,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();
@@ -3786,8 +3791,15 @@ var QueueConsumerOptionsSchema = /* @__PURE__ */ import_zod2.z.object({
   maxBatchTimeout: import_zod2.z.number().min(0).max(30).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,
@@ -3854,8 +3866,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;
   }
@@ -4363,14 +4375,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()) {
@@ -4382,10 +4394,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
@@ -4444,8 +4456,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) {
@@ -4458,16 +4470,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);
@@ -5079,12 +5091,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;
@@ -5098,30 +5110,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.`
@@ -5133,8 +5145,8 @@ function parseRoutes(allRoutes) {
         specificity,
         protocol,
         allowHostnamePrefix,
-        hostname: anyHostname ? "" : url17.hostname,
-        path: url17.pathname,
+        hostname: anyHostname ? "" : url18.hostname,
+        path: url18.pathname,
         allowPathSuffix
       });
     }
@@ -5175,11 +5187,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 {
   }
 }
@@ -5188,16 +5200,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;
@@ -5817,60 +5829,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"
@@ -6073,8 +6085,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;
@@ -6089,8 +6101,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) {
@@ -6274,7 +6286,7 @@ var SynchronousFetcher = class {
       transferList: [this.#channel.port2]
     });
   }
-  fetch(url17, init2) {
+  fetch(url18, init2) {
     this.#ensureWorker();
     Atomics.store(
       this.#notifyHandle,
@@ -6287,7 +6299,7 @@ var SynchronousFetcher = class {
     this.#channel.port1.postMessage({
       id,
       method: init2.method,
-      url: url17.toString(),
+      url: url18.toString(),
       headers: init2.headers,
       body: init2.body
     });
@@ -6407,8 +6419,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);
   }
@@ -7106,7 +7118,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 }))
         )
       );
     }
@@ -7179,7 +7191,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])
         )
       );
     }
@@ -7752,9 +7764,9 @@ var encodeManifest = (manifest) => {
 var bytesToHex = (buffer) => {
   return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
 };
-var hashPath = async (path27) => {
+var hashPath = async (path28) => {
   const encoder3 = new TextEncoder();
-  const data = encoder3.encode(path27);
+  const data = encoder3.encode(path28);
   const hashBuffer = await import_node_crypto.default.subtle.digest("SHA-256", data.buffer);
   return new Uint8Array(hashBuffer, 0, PATH_HASH_SIZE);
 };
@@ -7895,55 +7907,55 @@ var D1_PLUGIN = {
 var import_node_assert3 = __toESM(require("node:assert"));
 var import_zod15 = require("zod");
 var HYPERDRIVE_PLUGIN_NAME = "hyperdrive";
-function hasPostgresProtocol(url17) {
-  return url17.protocol === "postgresql:" || url17.protocol === "postgres:";
+function hasPostgresProtocol(url18) {
+  return url18.protocol === "postgresql:" || url18.protocol === "postgres:";
 }
-function getPort(url17) {
-  if (url17.port !== "")
-    return url17.port;
-  if (hasPostgresProtocol(url17))
+function getPort(url18) {
+  if (url18.port !== "")
+    return url18.port;
+  if (hasPostgresProtocol(url18))
     return "5432";
-  import_node_assert3.default.fail(`Expected known protocol, got ${url17.protocol}`);
+  import_node_assert3.default.fail(`Expected known protocol, got ${url18.protocol}`);
 }
-var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url17, ctx) => {
-  if (typeof url17 === "string")
-    url17 = new URL(url17);
-  if (url17.protocol === "") {
+var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url18, ctx) => {
+  if (typeof url18 === "string")
+    url18 = new URL(url18);
+  if (url18.protocol === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must specify the database protocol - e.g. 'postgresql'."
     });
-  } else if (!hasPostgresProtocol(url17)) {
+  } else if (!hasPostgresProtocol(url18)) {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "Only PostgreSQL or PostgreSQL compatible databases are currently supported."
     });
   }
-  if (url17.host === "") {
+  if (url18.host === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a hostname or IP address in your connection string - e.g. 'user:password@database-hostname.example.com:5432/databasename"
     });
   }
-  if (url17.pathname === "") {
+  if (url18.pathname === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a database name as the path component - e.g. /postgres"
     });
   }
-  if (url17.username === "") {
+  if (url18.username === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a username - e.g. 'user:password@database.example.com:port/databasename'"
     });
   }
-  if (url17.password === "") {
+  if (url18.password === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
       message: "You must provide a password - e.g. 'user:password@database.example.com:port/databasename' "
     });
   }
-  return url17;
+  return url18;
 });
 var HyperdriveInputOptionsSchema = import_zod15.z.object({
   hyperdrives: import_zod15.z.record(import_zod15.z.string(), HyperdriveSchema).optional()
@@ -7952,9 +7964,9 @@ var HYPERDRIVE_PLUGIN = {
   options: HyperdriveInputOptionsSchema,
   getBindings(options) {
     return Object.entries(options.hyperdrives ?? {}).map(
-      ([name, url17]) => {
-        const database = url17.pathname.replace("/", "");
-        const scheme = url17.protocol.replace(":", "");
+      ([name, url18]) => {
+        const database = url18.pathname.replace("/", "");
+        const scheme = url18.protocol.replace(":", "");
         return {
           name,
           hyperdrive: {
@@ -7962,8 +7974,8 @@ var HYPERDRIVE_PLUGIN = {
               name: `${HYPERDRIVE_PLUGIN_NAME}:${name}`
             },
             database: decodeURIComponent(database),
-            user: decodeURIComponent(url17.username),
-            password: decodeURIComponent(url17.password),
+            user: decodeURIComponent(url18.username),
+            password: decodeURIComponent(url18.password),
             scheme
           }
         };
@@ -7972,11 +7984,11 @@ var HYPERDRIVE_PLUGIN = {
   },
   getNodeBindings(options) {
     return Object.fromEntries(
-      Object.entries(options.hyperdrives ?? {}).map(([name, url17]) => {
+      Object.entries(options.hyperdrives ?? {}).map(([name, url18]) => {
         const connectionOverrides = {
-          connectionString: `${url17}`,
-          port: Number.parseInt(url17.port),
-          host: url17.hostname
+          connectionString: `${url18}`,
+          port: Number.parseInt(url18.port),
+          host: url18.hostname
         };
         const proxyNodeBinding = new ProxyNodeBinding({
           get(target, prop) {
@@ -7989,10 +8001,10 @@ var HYPERDRIVE_PLUGIN = {
   },
   async getServices({ options }) {
     return Object.entries(options.hyperdrives ?? {}).map(
-      ([name, url17]) => ({
+      ([name, url18]) => ({
         name: `${HYPERDRIVE_PLUGIN_NAME}:${name}`,
         external: {
-          address: `${url17.hostname}:${getPort(url17)}`,
+          address: `${url18.hostname}:${getPort(url18)}`,
           tcp: {}
         }
       })
@@ -8326,7 +8338,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 },
@@ -8589,6 +8605,122 @@ 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 storageService = {
+      name: WORKFLOWS_STORAGE_SERVICE_NAME,
+      disk: { path: persistPath, writable: true }
+    };
+    const services = Object.entries(options.workflows ?? {}).map(
+      ([_bindingName, workflow]) => {
+        const uniqueKey = `miniflare-workflows`;
+        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
+              }
+            ],
+            // this might conflict between workflows
+            durableObjectStorage: { localDisk: WORKFLOWS_STORAGE_SERVICE_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 [storageService, ...services];
+  },
+  getPersistPath({ workflowsPersist }, tmpPath) {
+    return getPersistPath(WORKFLOWS_PLUGIN_NAME, tmpPath, workflowsPersist);
+  }
+};
+
 // src/plugins/index.ts
 var PLUGINS = {
   [CORE_PLUGIN_NAME2]: CORE_PLUGIN,
@@ -8600,7 +8732,8 @@ var PLUGINS = {
   [R2_PLUGIN_NAME]: R2_PLUGIN,
   [HYPERDRIVE_PLUGIN_NAME]: HYPERDRIVE_PLUGIN,
   [RATELIMIT_PLUGIN_NAME]: RATELIMIT_PLUGIN,
-  [ASSETS_PLUGIN_NAME]: ASSETS_PLUGIN
+  [ASSETS_PLUGIN_NAME]: ASSETS_PLUGIN,
+  [WORKFLOWS_PLUGIN_NAME]: WORKFLOWS_PLUGIN
 };
 var PLUGIN_ENTRIES = Object.entries(PLUGINS);
 
@@ -8706,8 +8839,8 @@ function hasMultipleDistinctMessages(issues, atDepth) {
   }
   return false;
 }
-function annotate(groupCounts, annotated, input, issue, path27, groupId) {
-  if (path27.length === 0) {
+function annotate(groupCounts, annotated, input, issue, path28, groupId) {
+  if (path28.length === 0) {
     if (issue.code === "invalid_union") {
       const unionIssues = issue.unionErrors.flatMap(({ issues }) => issues);
       let newGroupId;
@@ -8754,7 +8887,7 @@ function annotate(groupCounts, annotated, input, issue, path27, groupId) {
       [kGroupId]: groupId
     };
   }
-  const [head, ...tail] = path27;
+  const [head, ...tail] = path28;
   (0, import_assert11.default)(isRecord(input), "Expected object/array input for nested issue");
   if (annotated === void 0) {
     if (Array.isArray(input)) {
@@ -8964,7 +9097,7 @@ function validateOptions(opts) {
   );
   const sharedRootPath = multipleWorkers ? getRootPath(sharedOpts) : "";
   const workerRootPaths = workerOpts.map(
-    (opts2) => import_path25.default.resolve(sharedRootPath, getRootPath(opts2))
+    (opts2) => import_path26.default.resolve(sharedRootPath, getRootPath(opts2))
   );
   try {
     for (const [key, plugin] of PLUGIN_ENTRIES) {
@@ -8980,7 +9113,7 @@ function validateOptions(opts) {
       }
     }
   } catch (e) {
-    if (e instanceof import_zod21.z.ZodError) {
+    if (e instanceof import_zod22.z.ZodError) {
       let formatted;
       try {
         formatted = formatZodError(e, opts);
@@ -9392,7 +9525,7 @@ var Miniflare2 = class {
         }
       }
     });
-    this.#tmpPath = import_path25.default.join(
+    this.#tmpPath = import_path26.default.join(
       import_os2.default.tmpdir(),
       `miniflare-${import_crypto3.default.randomBytes(16).toString("hex")}`
     );
@@ -9400,7 +9533,7 @@ var Miniflare2 = class {
     this.#removeExitHook = (0, import_exit_hook.default)(() => {
       void this.#runtime?.dispose();
       try {
-        import_fs21.default.rmSync(this.#tmpPath, { force: true, recursive: true });
+        import_fs22.default.rmSync(this.#tmpPath, { force: true, recursive: true });
       } catch (e) {
         this.#log.debug(`Unable to remove temporary directory: ${String(e)}`);
       }
@@ -9437,7 +9570,7 @@ var Miniflare2 = class {
       if (!(response instanceof Response)) {
         response = new Response(response.body, response);
       }
-      return import_zod21.z.instanceof(Response).parse(response);
+      return import_zod22.z.instanceof(Response).parse(response);
     } catch (e) {
       return new Response(e?.stack ?? e, { status: 500 });
     }
@@ -9462,11 +9595,11 @@ var Miniflare2 = class {
     (0, import_assert12.default)(!Array.isArray(cfBlob));
     const cf = cfBlob ? JSON.parse(cfBlob) : void 0;
     const originalUrl = headers.get(CoreHeaders.ORIGINAL_URL);
-    const url17 = new URL(originalUrl ?? req.url ?? "", "http://localhost");
+    const url18 = new URL(originalUrl ?? req.url ?? "", "http://localhost");
     headers.delete(CoreHeaders.ORIGINAL_URL);
     const noBody = req.method === "GET" || req.method === "HEAD";
     const body = noBody ? void 0 : safeReadableStreamFrom(req);
-    const request = new Request(url17, {
+    const request = new Request(url18, {
       method: req.method,
       headers,
       body,
@@ -9487,13 +9620,13 @@ var Miniflare2 = class {
           request,
           this
         );
-      } else if (url17.pathname === "/core/error") {
+      } else if (url18.pathname === "/core/error") {
         response = await handlePrettyErrorRequest(
           this.#log,
           this.#workerSrcOpts,
           request
         );
-      } else if (url17.pathname === "/core/log") {
+      } else if (url18.pathname === "/core/log") {
         const level = parseInt(request.headers.get(SharedHeaders.LOG_LEVEL));
         (0, import_assert12.default)(
           0 /* NONE */ <= level && level <= 5 /* VERBOSE */,
@@ -9643,6 +9776,11 @@ var Miniflare2 = class {
       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 = [];
@@ -9975,11 +10113,11 @@ var Miniflare2 = class {
     (0, import_assert12.default)(this.#runtimeEntryURL !== void 0);
     (0, import_assert12.default)(this.#runtimeDispatcher !== void 0);
     const forward = new Request(input, init2);
-    const url17 = new URL(forward.url);
+    const url18 = new URL(forward.url);
     const actualRuntimeOrigin = this.#runtimeEntryURL.origin;
-    const userRuntimeOrigin = url17.origin;
-    url17.protocol = this.#runtimeEntryURL.protocol;
-    url17.host = this.#runtimeEntryURL.host;
+    const userRuntimeOrigin = url18.origin;
+    url18.protocol = this.#runtimeEntryURL.protocol;
+    url18.host = this.#runtimeEntryURL.host;
     if (forward.body !== null && forward.headers.get("Content-Length") === "0") {
       forward.headers.delete("Content-Length");
     }
@@ -9993,7 +10131,7 @@ var Miniflare2 = class {
     );
     const forwardInit = forward;
     forwardInit.dispatcher = dispatcher;
-    const response = await fetch3(url17, forwardInit);
+    const response = await fetch3(url18, forwardInit);
     const stack = response.headers.get(CoreHeaders.ERROR_STACK);
     if (response.status === 500 && stack !== null) {
       const caught = JsonErrorSchema.parse(await response.json());
@@ -10143,7 +10281,7 @@ var Miniflare2 = class {
       await this.#proxyClient?.dispose();
       await this.#runtime?.dispose();
       await this.#stopLoopbackServer();
-      await import_fs21.default.promises.rm(this.#tmpPath, { force: true, recursive: true });
+      await import_fs22.default.promises.rm(this.#tmpPath, { force: true, recursive: true });
       maybeInstanceRegistry?.delete(this);
     }
   }
@@ -10256,10 +10394,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,