inngest 3.48.2-pr-1209.2 → 3.49.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # inngest
 
+## 3.49.1
+
+### Patch Changes
+
+- [#1234](https://github.com/inngest/inngest-js/pull/1234) [`c85e2f29`](https://github.com/inngest/inngest-js/commit/c85e2f297a782e78fe4b681793464e5b60045c23) Thanks [@amh4r](https://github.com/amh4r)! - Fix not treating Next Request.body as a ReadableStream
+
 ## 3.49.0
 
 ### Minor Changes

package/h3.cjs

@@ -1,5 +1,4 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_strings = require('./helpers/strings.cjs');
 const require_env = require('./helpers/env.cjs');
 const require_InngestCommHandler = require('./components/InngestCommHandler.cjs');
 let h3 = require("h3");
@@ -38,50 +37,6 @@ let h3 = require("h3");
 * dashboards and during testing.
 */
 const frameworkName = "h3";
-const commHandler = (options, syncOptions) => {
-	return new require_InngestCommHandler.InngestCommHandler({
-		frameworkName,
-		...options,
-		syncOptions,
-		handler: (event) => {
-			return {
-				body: () => (0, h3.readBody)(event),
-				textBody: async () => {
-					const method = event.method;
-					return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE" ? await (0, h3.readRawBody)(event, "utf-8") ?? "" : "";
-				},
-				headers: (key) => (0, h3.getHeader)(event, key),
-				method: () => event.method,
-				url: () => {
-					let scheme = "https";
-					if ((require_env.processEnv("NODE_ENV") ?? "dev").startsWith("dev")) scheme = "http";
-					return new URL(String(event.path), `${scheme}://${String((0, h3.getHeader)(event, "host"))}`);
-				},
-				queryString: (key) => {
-					const param = (0, h3.getQuery)(event)[key];
-					if (param) return String(param);
-				},
-				transformResponse: (actionRes) => {
-					const { res } = event.node;
-					res.statusCode = actionRes.status;
-					(0, h3.setHeaders)(event, actionRes.headers);
-					return (0, h3.send)(event, actionRes.body);
-				},
-				experimentalTransformSyncResponse: async (data) => {
-					const headers = Object.entries((0, h3.getResponseHeaders)(event) ?? {}).reduce((acc, [key, value]) => {
-						acc[key] = Array.isArray(value) ? value.join(",") : `${value}`;
-						return acc;
-					}, {});
-					return {
-						body: typeof data === "string" ? data : require_strings.stringify(data),
-						headers,
-						status: (0, h3.getResponseStatus)(event) ?? 200
-					};
-				}
-			};
-		}
-	});
-};
 /**
 * In h3, serve and register any declared functions with Inngest, making
 * them available to be triggered by events.
@@ -111,45 +66,35 @@ const commHandler = (options, syncOptions) => {
 * @public
 */
 const serve = (options) => {
-	return commHandler(options).createHandler();
-};
-/**
-* In h3, create a function that can define an event handler with Inngest steps
-* enabled, allowing you to use steps seamlessly within that API.
-*
-* @example
-* ```ts
-* import { Inngest, step } from "inngest";
-* import { createExperimentalEndpointWrapper } from "inngest/h3";
-*
-* const inngestEventHandler = createExperimentalEndpointWrapper({
-*   client: new Inngest({ id: "h3-sync-example" }),
-* });
-*
-*
-* export default inngestEventHandler(async (event) => {
-*   const foo = await step.run("example/step", async () => {
-*     return "Hello from step!";
-*   });
-*
-*   return `
-*       <meta charset="utf-8">
-*       <h1>This endpoint worked!</h1>
-*       <p>The step's result was: ${foo}</p>
-*     `;
-* });
-* ```
-*/
-const createExperimentalEndpointWrapper = (options) => {
-	const inngestWrapper = commHandler(options, options).createSyncHandler();
-	const h3Handler = (userlandHandler) => {
-		return (0, h3.defineEventHandler)(inngestWrapper(userlandHandler));
-	};
-	return h3Handler;
+	return new require_InngestCommHandler.InngestCommHandler({
+		frameworkName,
+		...options,
+		handler: (event) => {
+			return {
+				body: () => (0, h3.readBody)(event),
+				headers: (key) => (0, h3.getHeader)(event, key),
+				method: () => event.method,
+				url: () => {
+					let scheme = "https";
+					if ((require_env.processEnv("NODE_ENV") ?? "dev").startsWith("dev")) scheme = "http";
+					return new URL(String(event.path), `${scheme}://${String((0, h3.getHeader)(event, "host"))}`);
+				},
+				queryString: (key) => {
+					const param = (0, h3.getQuery)(event)[key];
+					if (param) return String(param);
+				},
+				transformResponse: (actionRes) => {
+					const { res } = event.node;
+					res.statusCode = actionRes.status;
+					(0, h3.setHeaders)(event, actionRes.headers);
+					return (0, h3.send)(event, actionRes.body);
+				}
+			};
+		}
+	}).createHandler();
 };
 
 //#endregion
-exports.createExperimentalEndpointWrapper = createExperimentalEndpointWrapper;
 exports.frameworkName = frameworkName;
 exports.serve = serve;
 //# sourceMappingURL=h3.cjs.map

package/h3.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"h3.cjs","names":["frameworkName: SupportedFrameworkName","InngestCommHandler","processEnv","stringify","h3Handler: typeof inngestWrapper"],"sources":["../src/h3.ts"],"sourcesContent":["/**\n * An adapter for H3 to serve and register any declared functions with Inngest,\n * making them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @module\n */\n\nimport {\n  defineEventHandler,\n  type EventHandlerRequest,\n  type EventHandlerResponse,\n  getHeader,\n  getQuery,\n  getResponseHeaders,\n  getResponseStatus,\n  type H3Event,\n  readBody,\n  readRawBody,\n  send,\n  setHeaders,\n} from \"h3\";\nimport type { Inngest } from \"./components/Inngest.ts\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n  type SyncHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { processEnv } from \"./helpers/env.ts\";\nimport { stringify } from \"./helpers/strings.ts\";\nimport type { RegisterOptions, SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"h3\";\n\nconst commHandler = (\n  options: RegisterOptions & { client: Inngest.Like },\n  syncOptions?: SyncHandlerOptions,\n) => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    syncOptions,\n    handler: (event: H3Event<EventHandlerRequest>) => {\n      return {\n        body: () => readBody(event),\n        textBody: async () => {\n          const method = event.method;\n          const body =\n            method === \"POST\" ||\n            method === \"PUT\" ||\n            method === \"PATCH\" ||\n            method === \"DELETE\"\n              ? ((await readRawBody(event, \"utf-8\")) ?? \"\")\n              : \"\";\n\n          return body;\n        },\n        headers: (key) => getHeader(event, key),\n        method: () => event.method,\n        url: () => {\n          let scheme = \"https\";\n          if ((processEnv(\"NODE_ENV\") ?? \"dev\").startsWith(\"dev\")) {\n            scheme = \"http\";\n          }\n\n          return new URL(\n            String(event.path),\n            `${scheme}://${String(getHeader(event, \"host\"))}`,\n          );\n        },\n        queryString: (key) => {\n          const param = getQuery(event)[key];\n          if (param) {\n            return String(param);\n          }\n\n          return;\n        },\n        transformResponse: (actionRes): EventHandlerResponse => {\n          const { res } = event.node;\n          res.statusCode = actionRes.status;\n          setHeaders(event, actionRes.headers);\n          return send(event, actionRes.body);\n        },\n        experimentalTransformSyncResponse: async (data) => {\n          const headers = Object.entries(\n            getResponseHeaders(event) ?? {},\n          ).reduce(\n            (acc, [key, value]) => {\n              acc[key] = Array.isArray(value) ? value.join(\",\") : `${value}`;\n\n              return acc;\n            },\n            {} as Record<string, string>,\n          );\n\n          return {\n            body: typeof data === \"string\" ? data : stringify(data),\n            headers,\n            status: getResponseStatus(event) ?? 200,\n          };\n        },\n      };\n    },\n  });\n\n  return handler;\n};\n\n/**\n * In h3, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ((event: H3Event<EventHandlerRequest>) => Promise<void>) => {\n  return commHandler(options).createHandler();\n};\n\n/**\n * In h3, create a function that can define an event handler with Inngest steps\n * enabled, allowing you to use steps seamlessly within that API.\n *\n * @example\n * ```ts\n * import { Inngest, step } from \"inngest\";\n * import { createExperimentalEndpointWrapper } from \"inngest/h3\";\n *\n * const inngestEventHandler = createExperimentalEndpointWrapper({\n *   client: new Inngest({ id: \"h3-sync-example\" }),\n * });\n *\n *\n * export default inngestEventHandler(async (event) => {\n *   const foo = await step.run(\"example/step\", async () => {\n *     return \"Hello from step!\";\n *   });\n *\n *   return `\n *       <meta charset=\"utf-8\">\n *       <h1>This endpoint worked!</h1>\n *       <p>The step's result was: ${foo}</p>\n *     `;\n * });\n * ```\n */\nexport const createExperimentalEndpointWrapper = (\n  options: SyncHandlerOptions,\n) => {\n  const inngestWrapper = commHandler(options, options).createSyncHandler();\n\n  const h3Handler: typeof inngestWrapper = (userlandHandler) => {\n    return defineEventHandler(inngestWrapper(userlandHandler));\n  };\n\n  return h3Handler;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAaA,gBAAwC;AAErD,MAAM,eACJ,SACA,gBACG;AAqEH,QApEgB,IAAIC,8CAAmB;EACrC;EACA,GAAG;EACH;EACA,UAAU,UAAwC;AAChD,UAAO;IACL,6BAAqB,MAAM;IAC3B,UAAU,YAAY;KACpB,MAAM,SAAS,MAAM;AASrB,YAPE,WAAW,UACX,WAAW,SACX,WAAW,WACX,WAAW,WACL,0BAAkB,OAAO,QAAQ,IAAK,KACxC;;IAIR,UAAU,0BAAkB,OAAO,IAAI;IACvC,cAAc,MAAM;IACpB,WAAW;KACT,IAAI,SAAS;AACb,UAAKC,uBAAW,WAAW,IAAI,OAAO,WAAW,MAAM,CACrD,UAAS;AAGX,YAAO,IAAI,IACT,OAAO,MAAM,KAAK,EAClB,GAAG,OAAO,KAAK,yBAAiB,OAAO,OAAO,CAAC,GAChD;;IAEH,cAAc,QAAQ;KACpB,MAAM,yBAAiB,MAAM,CAAC;AAC9B,SAAI,MACF,QAAO,OAAO,MAAM;;IAKxB,oBAAoB,cAAoC;KACtD,MAAM,EAAE,QAAQ,MAAM;AACtB,SAAI,aAAa,UAAU;AAC3B,wBAAW,OAAO,UAAU,QAAQ;AACpC,yBAAY,OAAO,UAAU,KAAK;;IAEpC,mCAAmC,OAAO,SAAS;KACjD,MAAM,UAAU,OAAO,mCACF,MAAM,IAAI,EAAE,CAChC,CAAC,QACC,KAAK,CAAC,KAAK,WAAW;AACrB,UAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,IAAI,GAAG,GAAG;AAEvD,aAAO;QAET,EAAE,CACH;AAED,YAAO;MACL,MAAM,OAAO,SAAS,WAAW,OAAOC,0BAAU,KAAK;MACvD;MACA,kCAA0B,MAAM,IAAI;MACrC;;IAEJ;;EAEJ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCJ,MAAa,SACX,YAC6D;AAC7D,QAAO,YAAY,QAAQ,CAAC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B7C,MAAa,qCACX,YACG;CACH,MAAM,iBAAiB,YAAY,SAAS,QAAQ,CAAC,mBAAmB;CAExE,MAAMC,aAAoC,oBAAoB;AAC5D,oCAA0B,eAAe,gBAAgB,CAAC;;AAG5D,QAAO"}
+{"version":3,"file":"h3.cjs","names":["frameworkName: SupportedFrameworkName","InngestCommHandler","processEnv"],"sources":["../src/h3.ts"],"sourcesContent":["/**\n * An adapter for H3 to serve and register any declared functions with Inngest,\n * making them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @module\n */\n\nimport {\n  type EventHandlerRequest,\n  getHeader,\n  getQuery,\n  type H3Event,\n  readBody,\n  send,\n  setHeaders,\n} from \"h3\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { processEnv } from \"./helpers/env.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"h3\";\n\n/**\n * In h3, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ((event: H3Event<EventHandlerRequest>) => Promise<void>) => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (event: H3Event<EventHandlerRequest>) => {\n      return {\n        body: () => readBody(event),\n        headers: (key) => getHeader(event, key),\n        method: () => event.method,\n        url: () => {\n          let scheme = \"https\";\n          if ((processEnv(\"NODE_ENV\") ?? \"dev\").startsWith(\"dev\")) {\n            scheme = \"http\";\n          }\n\n          return new URL(\n            String(event.path),\n            `${scheme}://${String(getHeader(event, \"host\"))}`,\n          );\n        },\n        queryString: (key) => {\n          const param = getQuery(event)[key];\n          if (param) {\n            return String(param);\n          }\n\n          return;\n        },\n        transformResponse: (actionRes) => {\n          const { res } = event.node;\n          res.statusCode = actionRes.status;\n          setHeaders(event, actionRes.headers);\n          return send(event, actionRes.body);\n        },\n      };\n    },\n  });\n\n  return handler.createHandler();\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAaA,gBAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BrD,MAAa,SACX,YAC6D;AAsC7D,QArCgB,IAAIC,8CAAmB;EACrC;EACA,GAAG;EACH,UAAU,UAAwC;AAChD,UAAO;IACL,6BAAqB,MAAM;IAC3B,UAAU,0BAAkB,OAAO,IAAI;IACvC,cAAc,MAAM;IACpB,WAAW;KACT,IAAI,SAAS;AACb,UAAKC,uBAAW,WAAW,IAAI,OAAO,WAAW,MAAM,CACrD,UAAS;AAGX,YAAO,IAAI,IACT,OAAO,MAAM,KAAK,EAClB,GAAG,OAAO,KAAK,yBAAiB,OAAO,OAAO,CAAC,GAChD;;IAEH,cAAc,QAAQ;KACpB,MAAM,yBAAiB,MAAM,CAAC;AAC9B,SAAI,MACF,QAAO,OAAO,MAAM;;IAKxB,oBAAoB,cAAc;KAChC,MAAM,EAAE,QAAQ,MAAM;AACtB,SAAI,aAAa,UAAU;AAC3B,wBAAW,OAAO,UAAU,QAAQ;AACpC,yBAAY,OAAO,UAAU,KAAK;;IAErC;;EAEJ,CAAC,CAEa,eAAe"}

package/h3.d.cts

@@ -1,5 +1,5 @@
 import { SupportedFrameworkName } from "./types.cjs";
-import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.cjs";
+import { ServeHandlerOptions } from "./components/InngestCommHandler.cjs";
 import { EventHandlerRequest, H3Event } from "h3";
 
 //#region src/h3.d.ts
@@ -38,34 +38,6 @@ declare const frameworkName: SupportedFrameworkName;
  * @public
  */
 declare const serve: (options: ServeHandlerOptions) => ((event: H3Event<EventHandlerRequest>) => Promise<void>);
-/**
- * In h3, create a function that can define an event handler with Inngest steps
- * enabled, allowing you to use steps seamlessly within that API.
- *
- * @example
- * ```ts
- * import { Inngest, step } from "inngest";
- * import { createExperimentalEndpointWrapper } from "inngest/h3";
- *
- * const inngestEventHandler = createExperimentalEndpointWrapper({
- *   client: new Inngest({ id: "h3-sync-example" }),
- * });
- *
- *
- * export default inngestEventHandler(async (event) => {
- *   const foo = await step.run("example/step", async () => {
- *     return "Hello from step!";
- *   });
- *
- *   return `
- *       <meta charset="utf-8">
- *       <h1>This endpoint worked!</h1>
- *       <p>The step's result was: ${foo}</p>
- *     `;
- * });
- * ```
- */
-declare const createExperimentalEndpointWrapper: (options: SyncHandlerOptions) => (handler: (event: H3Event<EventHandlerRequest>) => Promise<any>) => (event: H3Event<EventHandlerRequest>) => Promise<any>;
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=h3.d.cts.map

package/h3.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"h3.d.cts","names":[],"sources":["../src/h3.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAyDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Gf,iBACF,iCACC,QAAQ,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BhC,6CACF,yCAAkB,QAAA,yBAAA,yBAAA,QAAA,yBAAA"}
+{"version":3,"file":"h3.d.cts","names":[],"sources":["../src/h3.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAiDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Bf,iBACF,iCACC,QAAQ,yBAAyB"}

package/h3.d.ts

@@ -1,5 +1,5 @@
 import { SupportedFrameworkName } from "./types.js";
-import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.js";
+import { ServeHandlerOptions } from "./components/InngestCommHandler.js";
 import { EventHandlerRequest, H3Event } from "h3";
 
 //#region src/h3.d.ts
@@ -38,34 +38,6 @@ declare const frameworkName: SupportedFrameworkName;
  * @public
  */
 declare const serve: (options: ServeHandlerOptions) => ((event: H3Event<EventHandlerRequest>) => Promise<void>);
-/**
- * In h3, create a function that can define an event handler with Inngest steps
- * enabled, allowing you to use steps seamlessly within that API.
- *
- * @example
- * ```ts
- * import { Inngest, step } from "inngest";
- * import { createExperimentalEndpointWrapper } from "inngest/h3";
- *
- * const inngestEventHandler = createExperimentalEndpointWrapper({
- *   client: new Inngest({ id: "h3-sync-example" }),
- * });
- *
- *
- * export default inngestEventHandler(async (event) => {
- *   const foo = await step.run("example/step", async () => {
- *     return "Hello from step!";
- *   });
- *
- *   return `
- *       <meta charset="utf-8">
- *       <h1>This endpoint worked!</h1>
- *       <p>The step's result was: ${foo}</p>
- *     `;
- * });
- * ```
- */
-declare const createExperimentalEndpointWrapper: (options: SyncHandlerOptions) => (handler: (event: H3Event<EventHandlerRequest>) => Promise<any>) => (event: H3Event<EventHandlerRequest>) => Promise<any>;
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=h3.d.ts.map

package/h3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"h3.d.ts","names":[],"sources":["../src/h3.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAyDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Gf,iBACF,iCACC,QAAQ,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BhC,6CACF,yCAAkB,QAAA,yBAAA,yBAAA,QAAA,yBAAA"}
+{"version":3,"file":"h3.d.ts","names":[],"sources":["../src/h3.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAiDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Bf,iBACF,iCACC,QAAQ,yBAAyB"}

package/h3.js

@@ -1,7 +1,6 @@
-import { stringify } from "./helpers/strings.js";
 import { processEnv } from "./helpers/env.js";
 import { InngestCommHandler } from "./components/InngestCommHandler.js";
-import { defineEventHandler, getHeader, getQuery, getResponseHeaders, getResponseStatus, readBody, readRawBody, send, setHeaders } from "h3";
+import { getHeader, getQuery, readBody, send, setHeaders } from "h3";
 
 //#region src/h3.ts
 /**
@@ -37,50 +36,6 @@ import { defineEventHandler, getHeader, getQuery, getResponseHeaders, getRespons
 * dashboards and during testing.
 */
 const frameworkName = "h3";
-const commHandler = (options, syncOptions) => {
-	return new InngestCommHandler({
-		frameworkName,
-		...options,
-		syncOptions,
-		handler: (event) => {
-			return {
-				body: () => readBody(event),
-				textBody: async () => {
-					const method = event.method;
-					return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE" ? await readRawBody(event, "utf-8") ?? "" : "";
-				},
-				headers: (key) => getHeader(event, key),
-				method: () => event.method,
-				url: () => {
-					let scheme = "https";
-					if ((processEnv("NODE_ENV") ?? "dev").startsWith("dev")) scheme = "http";
-					return new URL(String(event.path), `${scheme}://${String(getHeader(event, "host"))}`);
-				},
-				queryString: (key) => {
-					const param = getQuery(event)[key];
-					if (param) return String(param);
-				},
-				transformResponse: (actionRes) => {
-					const { res } = event.node;
-					res.statusCode = actionRes.status;
-					setHeaders(event, actionRes.headers);
-					return send(event, actionRes.body);
-				},
-				experimentalTransformSyncResponse: async (data) => {
-					const headers = Object.entries(getResponseHeaders(event) ?? {}).reduce((acc, [key, value]) => {
-						acc[key] = Array.isArray(value) ? value.join(",") : `${value}`;
-						return acc;
-					}, {});
-					return {
-						body: typeof data === "string" ? data : stringify(data),
-						headers,
-						status: getResponseStatus(event) ?? 200
-					};
-				}
-			};
-		}
-	});
-};
 /**
 * In h3, serve and register any declared functions with Inngest, making
 * them available to be triggered by events.
@@ -110,43 +65,34 @@ const commHandler = (options, syncOptions) => {
 * @public
 */
 const serve = (options) => {
-	return commHandler(options).createHandler();
-};
-/**
-* In h3, create a function that can define an event handler with Inngest steps
-* enabled, allowing you to use steps seamlessly within that API.
-*
-* @example
-* ```ts
-* import { Inngest, step } from "inngest";
-* import { createExperimentalEndpointWrapper } from "inngest/h3";
-*
-* const inngestEventHandler = createExperimentalEndpointWrapper({
-*   client: new Inngest({ id: "h3-sync-example" }),
-* });
-*
-*
-* export default inngestEventHandler(async (event) => {
-*   const foo = await step.run("example/step", async () => {
-*     return "Hello from step!";
-*   });
-*
-*   return `
-*       <meta charset="utf-8">
-*       <h1>This endpoint worked!</h1>
-*       <p>The step's result was: ${foo}</p>
-*     `;
-* });
-* ```
-*/
-const createExperimentalEndpointWrapper = (options) => {
-	const inngestWrapper = commHandler(options, options).createSyncHandler();
-	const h3Handler = (userlandHandler) => {
-		return defineEventHandler(inngestWrapper(userlandHandler));
-	};
-	return h3Handler;
+	return new InngestCommHandler({
+		frameworkName,
+		...options,
+		handler: (event) => {
+			return {
+				body: () => readBody(event),
+				headers: (key) => getHeader(event, key),
+				method: () => event.method,
+				url: () => {
+					let scheme = "https";
+					if ((processEnv("NODE_ENV") ?? "dev").startsWith("dev")) scheme = "http";
+					return new URL(String(event.path), `${scheme}://${String(getHeader(event, "host"))}`);
+				},
+				queryString: (key) => {
+					const param = getQuery(event)[key];
+					if (param) return String(param);
+				},
+				transformResponse: (actionRes) => {
+					const { res } = event.node;
+					res.statusCode = actionRes.status;
+					setHeaders(event, actionRes.headers);
+					return send(event, actionRes.body);
+				}
+			};
+		}
+	}).createHandler();
 };
 
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=h3.js.map

package/h3.js.map

@@ -1 +1 @@
-{"version":3,"file":"h3.js","names":["frameworkName: SupportedFrameworkName","h3Handler: typeof inngestWrapper"],"sources":["../src/h3.ts"],"sourcesContent":["/**\n * An adapter for H3 to serve and register any declared functions with Inngest,\n * making them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @module\n */\n\nimport {\n  defineEventHandler,\n  type EventHandlerRequest,\n  type EventHandlerResponse,\n  getHeader,\n  getQuery,\n  getResponseHeaders,\n  getResponseStatus,\n  type H3Event,\n  readBody,\n  readRawBody,\n  send,\n  setHeaders,\n} from \"h3\";\nimport type { Inngest } from \"./components/Inngest.ts\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n  type SyncHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { processEnv } from \"./helpers/env.ts\";\nimport { stringify } from \"./helpers/strings.ts\";\nimport type { RegisterOptions, SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"h3\";\n\nconst commHandler = (\n  options: RegisterOptions & { client: Inngest.Like },\n  syncOptions?: SyncHandlerOptions,\n) => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    syncOptions,\n    handler: (event: H3Event<EventHandlerRequest>) => {\n      return {\n        body: () => readBody(event),\n        textBody: async () => {\n          const method = event.method;\n          const body =\n            method === \"POST\" ||\n            method === \"PUT\" ||\n            method === \"PATCH\" ||\n            method === \"DELETE\"\n              ? ((await readRawBody(event, \"utf-8\")) ?? \"\")\n              : \"\";\n\n          return body;\n        },\n        headers: (key) => getHeader(event, key),\n        method: () => event.method,\n        url: () => {\n          let scheme = \"https\";\n          if ((processEnv(\"NODE_ENV\") ?? \"dev\").startsWith(\"dev\")) {\n            scheme = \"http\";\n          }\n\n          return new URL(\n            String(event.path),\n            `${scheme}://${String(getHeader(event, \"host\"))}`,\n          );\n        },\n        queryString: (key) => {\n          const param = getQuery(event)[key];\n          if (param) {\n            return String(param);\n          }\n\n          return;\n        },\n        transformResponse: (actionRes): EventHandlerResponse => {\n          const { res } = event.node;\n          res.statusCode = actionRes.status;\n          setHeaders(event, actionRes.headers);\n          return send(event, actionRes.body);\n        },\n        experimentalTransformSyncResponse: async (data) => {\n          const headers = Object.entries(\n            getResponseHeaders(event) ?? {},\n          ).reduce(\n            (acc, [key, value]) => {\n              acc[key] = Array.isArray(value) ? value.join(\",\") : `${value}`;\n\n              return acc;\n            },\n            {} as Record<string, string>,\n          );\n\n          return {\n            body: typeof data === \"string\" ? data : stringify(data),\n            headers,\n            status: getResponseStatus(event) ?? 200,\n          };\n        },\n      };\n    },\n  });\n\n  return handler;\n};\n\n/**\n * In h3, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ((event: H3Event<EventHandlerRequest>) => Promise<void>) => {\n  return commHandler(options).createHandler();\n};\n\n/**\n * In h3, create a function that can define an event handler with Inngest steps\n * enabled, allowing you to use steps seamlessly within that API.\n *\n * @example\n * ```ts\n * import { Inngest, step } from \"inngest\";\n * import { createExperimentalEndpointWrapper } from \"inngest/h3\";\n *\n * const inngestEventHandler = createExperimentalEndpointWrapper({\n *   client: new Inngest({ id: \"h3-sync-example\" }),\n * });\n *\n *\n * export default inngestEventHandler(async (event) => {\n *   const foo = await step.run(\"example/step\", async () => {\n *     return \"Hello from step!\";\n *   });\n *\n *   return `\n *       <meta charset=\"utf-8\">\n *       <h1>This endpoint worked!</h1>\n *       <p>The step's result was: ${foo}</p>\n *     `;\n * });\n * ```\n */\nexport const createExperimentalEndpointWrapper = (\n  options: SyncHandlerOptions,\n) => {\n  const inngestWrapper = commHandler(options, options).createSyncHandler();\n\n  const h3Handler: typeof inngestWrapper = (userlandHandler) => {\n    return defineEventHandler(inngestWrapper(userlandHandler));\n  };\n\n  return h3Handler;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAaA,gBAAwC;AAErD,MAAM,eACJ,SACA,gBACG;AAqEH,QApEgB,IAAI,mBAAmB;EACrC;EACA,GAAG;EACH;EACA,UAAU,UAAwC;AAChD,UAAO;IACL,YAAY,SAAS,MAAM;IAC3B,UAAU,YAAY;KACpB,MAAM,SAAS,MAAM;AASrB,YAPE,WAAW,UACX,WAAW,SACX,WAAW,WACX,WAAW,WACL,MAAM,YAAY,OAAO,QAAQ,IAAK,KACxC;;IAIR,UAAU,QAAQ,UAAU,OAAO,IAAI;IACvC,cAAc,MAAM;IACpB,WAAW;KACT,IAAI,SAAS;AACb,UAAK,WAAW,WAAW,IAAI,OAAO,WAAW,MAAM,CACrD,UAAS;AAGX,YAAO,IAAI,IACT,OAAO,MAAM,KAAK,EAClB,GAAG,OAAO,KAAK,OAAO,UAAU,OAAO,OAAO,CAAC,GAChD;;IAEH,cAAc,QAAQ;KACpB,MAAM,QAAQ,SAAS,MAAM,CAAC;AAC9B,SAAI,MACF,QAAO,OAAO,MAAM;;IAKxB,oBAAoB,cAAoC;KACtD,MAAM,EAAE,QAAQ,MAAM;AACtB,SAAI,aAAa,UAAU;AAC3B,gBAAW,OAAO,UAAU,QAAQ;AACpC,YAAO,KAAK,OAAO,UAAU,KAAK;;IAEpC,mCAAmC,OAAO,SAAS;KACjD,MAAM,UAAU,OAAO,QACrB,mBAAmB,MAAM,IAAI,EAAE,CAChC,CAAC,QACC,KAAK,CAAC,KAAK,WAAW;AACrB,UAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,IAAI,GAAG,GAAG;AAEvD,aAAO;QAET,EAAE,CACH;AAED,YAAO;MACL,MAAM,OAAO,SAAS,WAAW,OAAO,UAAU,KAAK;MACvD;MACA,QAAQ,kBAAkB,MAAM,IAAI;MACrC;;IAEJ;;EAEJ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCJ,MAAa,SACX,YAC6D;AAC7D,QAAO,YAAY,QAAQ,CAAC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B7C,MAAa,qCACX,YACG;CACH,MAAM,iBAAiB,YAAY,SAAS,QAAQ,CAAC,mBAAmB;CAExE,MAAMC,aAAoC,oBAAoB;AAC5D,SAAO,mBAAmB,eAAe,gBAAgB,CAAC;;AAG5D,QAAO"}
+{"version":3,"file":"h3.js","names":["frameworkName: SupportedFrameworkName"],"sources":["../src/h3.ts"],"sourcesContent":["/**\n * An adapter for H3 to serve and register any declared functions with Inngest,\n * making them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @module\n */\n\nimport {\n  type EventHandlerRequest,\n  getHeader,\n  getQuery,\n  type H3Event,\n  readBody,\n  send,\n  setHeaders,\n} from \"h3\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { processEnv } from \"./helpers/env.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"h3\";\n\n/**\n * In h3, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * @example\n * ```ts\n * import { createApp, eventHandler, toNodeListener } from \"h3\";\n * import { serve } from \"inngest/h3\";\n * import { createServer } from \"node:http\";\n * import { inngest } from \"./inngest/client\";\n * import fnA from \"./inngest/fnA\";\n *\n * const app = createApp();\n * app.use(\n *   \"/api/inngest\",\n *   eventHandler(\n *     serve({\n *       client: inngest,\n *       functions: [fnA],\n *     })\n *   )\n * );\n *\n * createServer(toNodeListener(app)).listen(process.env.PORT || 3000);\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ((event: H3Event<EventHandlerRequest>) => Promise<void>) => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (event: H3Event<EventHandlerRequest>) => {\n      return {\n        body: () => readBody(event),\n        headers: (key) => getHeader(event, key),\n        method: () => event.method,\n        url: () => {\n          let scheme = \"https\";\n          if ((processEnv(\"NODE_ENV\") ?? \"dev\").startsWith(\"dev\")) {\n            scheme = \"http\";\n          }\n\n          return new URL(\n            String(event.path),\n            `${scheme}://${String(getHeader(event, \"host\"))}`,\n          );\n        },\n        queryString: (key) => {\n          const param = getQuery(event)[key];\n          if (param) {\n            return String(param);\n          }\n\n          return;\n        },\n        transformResponse: (actionRes) => {\n          const { res } = event.node;\n          res.statusCode = actionRes.status;\n          setHeaders(event, actionRes.headers);\n          return send(event, actionRes.body);\n        },\n      };\n    },\n  });\n\n  return handler.createHandler();\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAaA,gBAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BrD,MAAa,SACX,YAC6D;AAsC7D,QArCgB,IAAI,mBAAmB;EACrC;EACA,GAAG;EACH,UAAU,UAAwC;AAChD,UAAO;IACL,YAAY,SAAS,MAAM;IAC3B,UAAU,QAAQ,UAAU,OAAO,IAAI;IACvC,cAAc,MAAM;IACpB,WAAW;KACT,IAAI,SAAS;AACb,UAAK,WAAW,WAAW,IAAI,OAAO,WAAW,MAAM,CACrD,UAAS;AAGX,YAAO,IAAI,IACT,OAAO,MAAM,KAAK,EAClB,GAAG,OAAO,KAAK,OAAO,UAAU,OAAO,OAAO,CAAC,GAChD;;IAEH,cAAc,QAAQ;KACpB,MAAM,QAAQ,SAAS,MAAM,CAAC;AAC9B,SAAI,MACF,QAAO,OAAO,MAAM;;IAKxB,oBAAoB,cAAc;KAChC,MAAM,EAAE,QAAQ,MAAM;AACtB,SAAI,aAAa,UAAU;AAC3B,gBAAW,OAAO,UAAU,QAAQ;AACpC,YAAO,KAAK,OAAO,UAAU,KAAK;;IAErC;;EAEJ,CAAC,CAEa,eAAe"}

package/next.cjs

@@ -70,7 +70,11 @@ const serve = (options) => {
 				return Array.isArray(header) ? header[0] : header;
 			};
 			return {
-				body: () => typeof req.json === "function" ? req.json() : req.body,
+				body: async () => {
+					if (typeof req.json === "function") return await req.json();
+					if (req.body instanceof ReadableStream) return await streamToJSON(req.body);
+					return req.body;
+				},
 				headers: getHeader,
 				method: () => {
 					return reqMethod || req.method || "";
@@ -177,6 +181,16 @@ const serve = (options) => {
 		PUT: { value: baseFn.bind(null, "PUT") }
 	});
 };
+async function streamToJSON(stream) {
+	const chunks = [];
+	const reader = stream.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+	}
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
 
 //#endregion
 exports.frameworkName = frameworkName;

package/next.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"next.cjs","names":["frameworkName: SupportedFrameworkName","InngestCommHandler","absoluteUrl: URL | undefined","host","scheme: \"http\" | \"https\"","getResponse"],"sources":["../src/next.ts"],"sourcesContent":["/**\n * An adapter for Next.js to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @module\n */\n\nimport type { NextApiRequest, NextApiResponse } from \"next\";\nimport type { NextRequest } from \"next/server\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { getResponse } from \"./helpers/env.ts\";\nimport type { Either } from \"./helpers/types.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nextjs\";\n\n/**\n * The shape of a request handler, supporting Next.js 12+.\n *\n * We are intentionally abstract with the arguments here, as Next.js's type\n * checking when building varies wildly between major versions; specifying\n * different types (even optional types) here can cause issues with the build.\n *\n * This change was initially made for Next.js 15, which specifies the second\n * argument as `RouteContext`, whereas Next.js 13 and 14 omit it and Next.js 12\n * provides a `NextApiResponse`, which is varies based on the execution\n * environment used (edge vs serverless).\n */\nexport type RequestHandler = (\n  expectedReq: NextRequest,\n  res: unknown,\n) => Promise<Response>;\n\nconst isRecord = (val: unknown): val is Record<string, unknown> => {\n  return typeof val === \"object\" && val !== null;\n};\n\nconst isFunction = (val: unknown): val is (...args: unknown[]) => unknown => {\n  return typeof val === \"function\";\n};\n\nconst isNext12ApiResponse = (val: unknown): val is NextApiResponse => {\n  return (\n    isRecord(val) &&\n    isFunction(val.setHeader) &&\n    isFunction(val.status) &&\n    isFunction(val.send)\n  );\n};\n\n/**\n * In Next.js, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): RequestHandler & {\n  GET: RequestHandler;\n  POST: RequestHandler;\n  PUT: RequestHandler;\n} => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (\n      reqMethod: \"GET\" | \"POST\" | \"PUT\" | undefined,\n      ...args: Parameters<RequestHandler>\n    ) => {\n      const [expectedReq, res] = args;\n      const req = expectedReq as Either<NextApiRequest, NextRequest>;\n\n      const getHeader = (key: string): string | null | undefined => {\n        const header =\n          typeof req.headers.get === \"function\"\n            ? req.headers.get(key)\n            : req.headers[key];\n\n        return Array.isArray(header) ? header[0] : header;\n      };\n\n      return {\n        body: () => (typeof req.json === \"function\" ? req.json() : req.body),\n        headers: getHeader,\n        method: () => {\n          /**\n           * `req.method`, though types say otherwise, is not available in Next.js\n           * 13 {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}.\n           *\n           * Therefore, we must try to set the method ourselves where we know it.\n           */\n          const method = reqMethod || req.method || \"\";\n          return method;\n        },\n        isProduction: () => {\n          /**\n           * Vercel Edge Functions do not allow dynamic access to environment\n           * variables, so we'll manage production checks directly here.\n           *\n           * We try/catch to avoid situations where Next.js is being used in\n           * environments where `process.env` is not accessible or polyfilled.\n           */\n          try {\n            const isProd = process.env.NODE_ENV === \"production\";\n            return isProd;\n          } catch (_err) {\n            // no-op\n          }\n\n          return;\n        },\n        queryString: (key, url) => {\n          const qs = req.query?.[key] || url.searchParams.get(key);\n          return Array.isArray(qs) ? qs[0] : qs;\n        },\n\n        url: () => {\n          let absoluteUrl: URL | undefined;\n          try {\n            absoluteUrl = new URL(req.url as string);\n          } catch {\n            // no-op\n          }\n\n          if (absoluteUrl) {\n            /**\n             * `req.url` here should may be the full URL, including query string.\n             * There are some caveats, however, where Next.js will obfuscate\n             * the host. For example, in the case of `host.docker.internal`,\n             * Next.js will instead set the host here to `localhost`.\n             *\n             * To avoid this, we'll try to parse the URL from `req.url`, but\n             * also use the `host` header if it's available.\n             */\n            const host = options.serveHost || getHeader(\"host\");\n            if (host) {\n              const hostWithProtocol = new URL(\n                host.includes(\"://\")\n                  ? host\n                  : `${absoluteUrl.protocol}//${host}`,\n              );\n\n              absoluteUrl.protocol = hostWithProtocol.protocol;\n              absoluteUrl.host = hostWithProtocol.host;\n              absoluteUrl.port = hostWithProtocol.port;\n              absoluteUrl.username = hostWithProtocol.username;\n              absoluteUrl.password = hostWithProtocol.password;\n            }\n\n            return absoluteUrl;\n          }\n\n          let scheme: \"http\" | \"https\" = \"https\";\n          const host = options.serveHost || getHeader(\"host\") || \"\";\n\n          try {\n            if (process.env.NODE_ENV === \"development\") {\n              scheme = \"http\";\n            }\n          } catch (_err) {\n            // no-op\n          }\n\n          const url = new URL(req.url as string, `${scheme}://${host}`);\n\n          return url;\n        },\n        transformResponse: ({ body, headers, status }): Response => {\n          /**\n           * Carefully attempt to set headers and data on the response object\n           * for Next.js 12 support.\n           *\n           * This also assumes that we're not using Next.js 15, where the `res`\n           * object is repopulated as a `RouteContext` object. We expect these\n           * methods to NOT be defined in Next.js 15.\n           *\n           * We could likely use `instanceof ServerResponse` to better check the\n           * type of this, though Next.js 12 had issues with this due to not\n           * instantiating the response correctly.\n           */\n          if (isNext12ApiResponse(res)) {\n            for (const [key, value] of Object.entries(headers)) {\n              res.setHeader(key, value);\n            }\n\n            res.status(status);\n            res.send(body);\n\n            /**\n             * If we're here, we're in a serverless endpoint (not edge), so\n             * we've correctly sent the response and can return `undefined`.\n             *\n             * Next.js 13 edge requires that the return value is typed as\n             * `Response`, so we still enforce that as we cannot dynamically\n             * adjust typing based on the environment.\n             */\n            return undefined as unknown as Response;\n          }\n\n          /**\n           * If we're here, we're in an edge environment and need to return a\n           * `Response` object.\n           *\n           * We also don't know if the current environment has a native\n           * `Response` object, so we'll grab that first.\n           */\n          const Res = getResponse();\n          return new Res(body, { status, headers });\n        },\n        transformStreamingResponse: ({ body, headers, status }) => {\n          return new Response(body, { status, headers });\n        },\n      };\n    },\n  });\n\n  /**\n   * Next.js 13 uses\n   * {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}\n   * to declare API routes instead of a generic catch-all method that was\n   * available using the `pages/api` directory.\n   *\n   * This means that users must now export a function for each method supported\n   * by the endpoint. For us, this means requiring a user explicitly exports\n   * `GET`, `POST`, and `PUT` functions.\n   *\n   * Because of this, we'll add circular references to those property names of\n   * the returned handler, meaning we can write some succinct code to export\n   * them. Thanks, @goodoldneon.\n   *\n   * @example\n   * ```ts\n   * export const { GET, POST, PUT } = serve(...);\n   * ```\n   *\n   * See {@link https://beta.nextjs.org/docs/routing/route-handlers}\n   */\n  const baseFn = handler.createHandler();\n\n  const fn = baseFn.bind(null, undefined);\n\n  /**\n   * Ensure we have a non-variadic length to avoid issues with forced type\n   * checking.\n   */\n  Object.defineProperty(fn, \"length\", { value: 1 });\n\n  type Fn = typeof fn;\n\n  const handlerFn = Object.defineProperties(fn, {\n    GET: { value: baseFn.bind(null, \"GET\") },\n    POST: { value: baseFn.bind(null, \"POST\") },\n    PUT: { value: baseFn.bind(null, \"PUT\") },\n  }) as Fn & {\n    GET: Fn;\n    POST: Fn;\n    PUT: Fn;\n  };\n\n  return handlerFn;\n};\n"],"mappings":";;;;;;;;AAoCA,MAAaA,gBAAwC;AAmBrD,MAAM,YAAY,QAAiD;AACjE,QAAO,OAAO,QAAQ,YAAY,QAAQ;;AAG5C,MAAM,cAAc,QAAyD;AAC3E,QAAO,OAAO,QAAQ;;AAGxB,MAAM,uBAAuB,QAAyC;AACpE,QACE,SAAS,IAAI,IACb,WAAW,IAAI,UAAU,IACzB,WAAW,IAAI,OAAO,IACtB,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;AA0BxB,MAAa,SACX,YAKG;;;;;;;;;;;;;;;;;;;;;;CAgLH,MAAM,SA/KU,IAAIC,8CAAmB;EACrC;EACA,GAAG;EACH,UACE,WACA,GAAG,SACA;GACH,MAAM,CAAC,aAAa,OAAO;GAC3B,MAAM,MAAM;GAEZ,MAAM,aAAa,QAA2C;IAC5D,MAAM,SACJ,OAAO,IAAI,QAAQ,QAAQ,aACvB,IAAI,QAAQ,IAAI,IAAI,GACpB,IAAI,QAAQ;AAElB,WAAO,MAAM,QAAQ,OAAO,GAAG,OAAO,KAAK;;AAG7C,UAAO;IACL,YAAa,OAAO,IAAI,SAAS,aAAa,IAAI,MAAM,GAAG,IAAI;IAC/D,SAAS;IACT,cAAc;AAQZ,YADe,aAAa,IAAI,UAAU;;IAG5C,oBAAoB;;;;;;;;AAQlB,SAAI;AAEF,aADe,QAAQ,IAAI,aAAa;cAEjC,MAAM;;IAMjB,cAAc,KAAK,QAAQ;KACzB,MAAM,KAAK,IAAI,QAAQ,QAAQ,IAAI,aAAa,IAAI,IAAI;AACxD,YAAO,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK;;IAGrC,WAAW;KACT,IAAIC;AACJ,SAAI;AACF,oBAAc,IAAI,IAAI,IAAI,IAAc;aAClC;AAIR,SAAI,aAAa;;;;;;;;;;MAUf,MAAMC,SAAO,QAAQ,aAAa,UAAU,OAAO;AACnD,UAAIA,QAAM;OACR,MAAM,mBAAmB,IAAI,IAC3BA,OAAK,SAAS,MAAM,GAChBA,SACA,GAAG,YAAY,SAAS,IAAIA,SACjC;AAED,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,WAAW,iBAAiB;;AAG1C,aAAO;;KAGT,IAAIC,SAA2B;KAC/B,MAAM,OAAO,QAAQ,aAAa,UAAU,OAAO,IAAI;AAEvD,SAAI;AACF,UAAI,QAAQ,IAAI,aAAa,cAC3B,UAAS;cAEJ,MAAM;AAMf,YAFY,IAAI,IAAI,IAAI,KAAe,GAAG,OAAO,KAAK,OAAO;;IAI/D,oBAAoB,EAAE,MAAM,SAAS,aAAuB;;;;;;;;;;;;;AAa1D,SAAI,oBAAoB,IAAI,EAAE;AAC5B,WAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,UAAU,KAAK,MAAM;AAG3B,UAAI,OAAO,OAAO;AAClB,UAAI,KAAK,KAAK;;;;;;;;;AAUd;;AAWF,YAAO,KADKC,yBAAa,EACV,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAE3C,6BAA6B,EAAE,MAAM,SAAS,aAAa;AACzD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEjD;;EAEJ,CAAC,CAuBqB,eAAe;CAEtC,MAAM,KAAK,OAAO,KAAK,MAAM,OAAU;;;;;AAMvC,QAAO,eAAe,IAAI,UAAU,EAAE,OAAO,GAAG,CAAC;AAcjD,QAVkB,OAAO,iBAAiB,IAAI;EAC5C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACxC,MAAM,EAAE,OAAO,OAAO,KAAK,MAAM,OAAO,EAAE;EAC1C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACzC,CAAC"}
+{"version":3,"file":"next.cjs","names":["frameworkName: SupportedFrameworkName","InngestCommHandler","absoluteUrl: URL | undefined","host","scheme: \"http\" | \"https\"","getResponse"],"sources":["../src/next.ts"],"sourcesContent":["/**\n * An adapter for Next.js to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @module\n */\n\nimport type { NextApiRequest, NextApiResponse } from \"next\";\nimport type { NextRequest } from \"next/server\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { getResponse } from \"./helpers/env.ts\";\nimport type { Either } from \"./helpers/types.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nextjs\";\n\n/**\n * The shape of a request handler, supporting Next.js 12+.\n *\n * We are intentionally abstract with the arguments here, as Next.js's type\n * checking when building varies wildly between major versions; specifying\n * different types (even optional types) here can cause issues with the build.\n *\n * This change was initially made for Next.js 15, which specifies the second\n * argument as `RouteContext`, whereas Next.js 13 and 14 omit it and Next.js 12\n * provides a `NextApiResponse`, which is varies based on the execution\n * environment used (edge vs serverless).\n */\nexport type RequestHandler = (\n  expectedReq: NextRequest,\n  res: unknown,\n) => Promise<Response>;\n\nconst isRecord = (val: unknown): val is Record<string, unknown> => {\n  return typeof val === \"object\" && val !== null;\n};\n\nconst isFunction = (val: unknown): val is (...args: unknown[]) => unknown => {\n  return typeof val === \"function\";\n};\n\nconst isNext12ApiResponse = (val: unknown): val is NextApiResponse => {\n  return (\n    isRecord(val) &&\n    isFunction(val.setHeader) &&\n    isFunction(val.status) &&\n    isFunction(val.send)\n  );\n};\n\n/**\n * In Next.js, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): RequestHandler & {\n  GET: RequestHandler;\n  POST: RequestHandler;\n  PUT: RequestHandler;\n} => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (\n      reqMethod: \"GET\" | \"POST\" | \"PUT\" | undefined,\n      ...args: Parameters<RequestHandler>\n    ) => {\n      const [expectedReq, res] = args;\n      const req = expectedReq as Either<NextApiRequest, NextRequest>;\n\n      const getHeader = (key: string): string | null | undefined => {\n        const header =\n          typeof req.headers.get === \"function\"\n            ? req.headers.get(key)\n            : req.headers[key];\n\n        return Array.isArray(header) ? header[0] : header;\n      };\n\n      return {\n        body: async () => {\n          if (typeof req.json === \"function\") {\n            return await req.json();\n          }\n\n          if (req.body instanceof ReadableStream) {\n            return await streamToJSON(req.body);\n          }\n\n          return req.body;\n        },\n        headers: getHeader,\n        method: () => {\n          /**\n           * `req.method`, though types say otherwise, is not available in Next.js\n           * 13 {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}.\n           *\n           * Therefore, we must try to set the method ourselves where we know it.\n           */\n          const method = reqMethod || req.method || \"\";\n          return method;\n        },\n        isProduction: () => {\n          /**\n           * Vercel Edge Functions do not allow dynamic access to environment\n           * variables, so we'll manage production checks directly here.\n           *\n           * We try/catch to avoid situations where Next.js is being used in\n           * environments where `process.env` is not accessible or polyfilled.\n           */\n          try {\n            const isProd = process.env.NODE_ENV === \"production\";\n            return isProd;\n          } catch (_err) {\n            // no-op\n          }\n\n          return;\n        },\n        queryString: (key, url) => {\n          const qs = req.query?.[key] || url.searchParams.get(key);\n          return Array.isArray(qs) ? qs[0] : qs;\n        },\n\n        url: () => {\n          let absoluteUrl: URL | undefined;\n          try {\n            absoluteUrl = new URL(req.url as string);\n          } catch {\n            // no-op\n          }\n\n          if (absoluteUrl) {\n            /**\n             * `req.url` here should may be the full URL, including query string.\n             * There are some caveats, however, where Next.js will obfuscate\n             * the host. For example, in the case of `host.docker.internal`,\n             * Next.js will instead set the host here to `localhost`.\n             *\n             * To avoid this, we'll try to parse the URL from `req.url`, but\n             * also use the `host` header if it's available.\n             */\n            const host = options.serveHost || getHeader(\"host\");\n            if (host) {\n              const hostWithProtocol = new URL(\n                host.includes(\"://\")\n                  ? host\n                  : `${absoluteUrl.protocol}//${host}`,\n              );\n\n              absoluteUrl.protocol = hostWithProtocol.protocol;\n              absoluteUrl.host = hostWithProtocol.host;\n              absoluteUrl.port = hostWithProtocol.port;\n              absoluteUrl.username = hostWithProtocol.username;\n              absoluteUrl.password = hostWithProtocol.password;\n            }\n\n            return absoluteUrl;\n          }\n\n          let scheme: \"http\" | \"https\" = \"https\";\n          const host = options.serveHost || getHeader(\"host\") || \"\";\n\n          try {\n            if (process.env.NODE_ENV === \"development\") {\n              scheme = \"http\";\n            }\n          } catch (_err) {\n            // no-op\n          }\n\n          const url = new URL(req.url as string, `${scheme}://${host}`);\n\n          return url;\n        },\n        transformResponse: ({ body, headers, status }): Response => {\n          /**\n           * Carefully attempt to set headers and data on the response object\n           * for Next.js 12 support.\n           *\n           * This also assumes that we're not using Next.js 15, where the `res`\n           * object is repopulated as a `RouteContext` object. We expect these\n           * methods to NOT be defined in Next.js 15.\n           *\n           * We could likely use `instanceof ServerResponse` to better check the\n           * type of this, though Next.js 12 had issues with this due to not\n           * instantiating the response correctly.\n           */\n          if (isNext12ApiResponse(res)) {\n            for (const [key, value] of Object.entries(headers)) {\n              res.setHeader(key, value);\n            }\n\n            res.status(status);\n            res.send(body);\n\n            /**\n             * If we're here, we're in a serverless endpoint (not edge), so\n             * we've correctly sent the response and can return `undefined`.\n             *\n             * Next.js 13 edge requires that the return value is typed as\n             * `Response`, so we still enforce that as we cannot dynamically\n             * adjust typing based on the environment.\n             */\n            return undefined as unknown as Response;\n          }\n\n          /**\n           * If we're here, we're in an edge environment and need to return a\n           * `Response` object.\n           *\n           * We also don't know if the current environment has a native\n           * `Response` object, so we'll grab that first.\n           */\n          const Res = getResponse();\n          return new Res(body, { status, headers });\n        },\n        transformStreamingResponse: ({ body, headers, status }) => {\n          return new Response(body, { status, headers });\n        },\n      };\n    },\n  });\n\n  /**\n   * Next.js 13 uses\n   * {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}\n   * to declare API routes instead of a generic catch-all method that was\n   * available using the `pages/api` directory.\n   *\n   * This means that users must now export a function for each method supported\n   * by the endpoint. For us, this means requiring a user explicitly exports\n   * `GET`, `POST`, and `PUT` functions.\n   *\n   * Because of this, we'll add circular references to those property names of\n   * the returned handler, meaning we can write some succinct code to export\n   * them. Thanks, @goodoldneon.\n   *\n   * @example\n   * ```ts\n   * export const { GET, POST, PUT } = serve(...);\n   * ```\n   *\n   * See {@link https://beta.nextjs.org/docs/routing/route-handlers}\n   */\n  const baseFn = handler.createHandler();\n\n  const fn = baseFn.bind(null, undefined);\n\n  /**\n   * Ensure we have a non-variadic length to avoid issues with forced type\n   * checking.\n   */\n  Object.defineProperty(fn, \"length\", { value: 1 });\n\n  type Fn = typeof fn;\n\n  const handlerFn = Object.defineProperties(fn, {\n    GET: { value: baseFn.bind(null, \"GET\") },\n    POST: { value: baseFn.bind(null, \"POST\") },\n    PUT: { value: baseFn.bind(null, \"PUT\") },\n  }) as Fn & {\n    GET: Fn;\n    POST: Fn;\n    PUT: Fn;\n  };\n\n  return handlerFn;\n};\n\nasync function streamToJSON(stream: ReadableStream): Promise<unknown> {\n  const chunks = [];\n  const reader = stream.getReader();\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n  }\n  return JSON.parse(Buffer.concat(chunks).toString(\"utf8\"));\n}\n"],"mappings":";;;;;;;;AAoCA,MAAaA,gBAAwC;AAmBrD,MAAM,YAAY,QAAiD;AACjE,QAAO,OAAO,QAAQ,YAAY,QAAQ;;AAG5C,MAAM,cAAc,QAAyD;AAC3E,QAAO,OAAO,QAAQ;;AAGxB,MAAM,uBAAuB,QAAyC;AACpE,QACE,SAAS,IAAI,IACb,WAAW,IAAI,UAAU,IACzB,WAAW,IAAI,OAAO,IACtB,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;AA0BxB,MAAa,SACX,YAKG;;;;;;;;;;;;;;;;;;;;;;CA0LH,MAAM,SAzLU,IAAIC,8CAAmB;EACrC;EACA,GAAG;EACH,UACE,WACA,GAAG,SACA;GACH,MAAM,CAAC,aAAa,OAAO;GAC3B,MAAM,MAAM;GAEZ,MAAM,aAAa,QAA2C;IAC5D,MAAM,SACJ,OAAO,IAAI,QAAQ,QAAQ,aACvB,IAAI,QAAQ,IAAI,IAAI,GACpB,IAAI,QAAQ;AAElB,WAAO,MAAM,QAAQ,OAAO,GAAG,OAAO,KAAK;;AAG7C,UAAO;IACL,MAAM,YAAY;AAChB,SAAI,OAAO,IAAI,SAAS,WACtB,QAAO,MAAM,IAAI,MAAM;AAGzB,SAAI,IAAI,gBAAgB,eACtB,QAAO,MAAM,aAAa,IAAI,KAAK;AAGrC,YAAO,IAAI;;IAEb,SAAS;IACT,cAAc;AAQZ,YADe,aAAa,IAAI,UAAU;;IAG5C,oBAAoB;;;;;;;;AAQlB,SAAI;AAEF,aADe,QAAQ,IAAI,aAAa;cAEjC,MAAM;;IAMjB,cAAc,KAAK,QAAQ;KACzB,MAAM,KAAK,IAAI,QAAQ,QAAQ,IAAI,aAAa,IAAI,IAAI;AACxD,YAAO,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK;;IAGrC,WAAW;KACT,IAAIC;AACJ,SAAI;AACF,oBAAc,IAAI,IAAI,IAAI,IAAc;aAClC;AAIR,SAAI,aAAa;;;;;;;;;;MAUf,MAAMC,SAAO,QAAQ,aAAa,UAAU,OAAO;AACnD,UAAIA,QAAM;OACR,MAAM,mBAAmB,IAAI,IAC3BA,OAAK,SAAS,MAAM,GAChBA,SACA,GAAG,YAAY,SAAS,IAAIA,SACjC;AAED,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,WAAW,iBAAiB;;AAG1C,aAAO;;KAGT,IAAIC,SAA2B;KAC/B,MAAM,OAAO,QAAQ,aAAa,UAAU,OAAO,IAAI;AAEvD,SAAI;AACF,UAAI,QAAQ,IAAI,aAAa,cAC3B,UAAS;cAEJ,MAAM;AAMf,YAFY,IAAI,IAAI,IAAI,KAAe,GAAG,OAAO,KAAK,OAAO;;IAI/D,oBAAoB,EAAE,MAAM,SAAS,aAAuB;;;;;;;;;;;;;AAa1D,SAAI,oBAAoB,IAAI,EAAE;AAC5B,WAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,UAAU,KAAK,MAAM;AAG3B,UAAI,OAAO,OAAO;AAClB,UAAI,KAAK,KAAK;;;;;;;;;AAUd;;AAWF,YAAO,KADKC,yBAAa,EACV,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAE3C,6BAA6B,EAAE,MAAM,SAAS,aAAa;AACzD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEjD;;EAEJ,CAAC,CAuBqB,eAAe;CAEtC,MAAM,KAAK,OAAO,KAAK,MAAM,OAAU;;;;;AAMvC,QAAO,eAAe,IAAI,UAAU,EAAE,OAAO,GAAG,CAAC;AAcjD,QAVkB,OAAO,iBAAiB,IAAI;EAC5C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACxC,MAAM,EAAE,OAAO,OAAO,KAAK,MAAM,OAAO,EAAE;EAC1C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACzC,CAAC;;AASJ,eAAe,aAAa,QAA0C;CACpE,MAAM,SAAS,EAAE;CACjB,MAAM,SAAS,OAAO,WAAW;AACjC,QAAO,MAAM;EACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,MAAI,KACF;AAEF,SAAO,KAAK,MAAM;;AAEpB,QAAO,KAAK,MAAM,OAAO,OAAO,OAAO,CAAC,SAAS,OAAO,CAAC"}

package/next.js

@@ -70,7 +70,11 @@ const serve = (options) => {
 				return Array.isArray(header) ? header[0] : header;
 			};
 			return {
-				body: () => typeof req.json === "function" ? req.json() : req.body,
+				body: async () => {
+					if (typeof req.json === "function") return await req.json();
+					if (req.body instanceof ReadableStream) return await streamToJSON(req.body);
+					return req.body;
+				},
 				headers: getHeader,
 				method: () => {
 					return reqMethod || req.method || "";
@@ -177,6 +181,16 @@ const serve = (options) => {
 		PUT: { value: baseFn.bind(null, "PUT") }
 	});
 };
+async function streamToJSON(stream) {
+	const chunks = [];
+	const reader = stream.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+	}
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
 
 //#endregion
 export { frameworkName, serve };

package/next.js.map

@@ -1 +1 @@
-{"version":3,"file":"next.js","names":["frameworkName: SupportedFrameworkName","absoluteUrl: URL | undefined","host","scheme: \"http\" | \"https\""],"sources":["../src/next.ts"],"sourcesContent":["/**\n * An adapter for Next.js to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @module\n */\n\nimport type { NextApiRequest, NextApiResponse } from \"next\";\nimport type { NextRequest } from \"next/server\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { getResponse } from \"./helpers/env.ts\";\nimport type { Either } from \"./helpers/types.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nextjs\";\n\n/**\n * The shape of a request handler, supporting Next.js 12+.\n *\n * We are intentionally abstract with the arguments here, as Next.js's type\n * checking when building varies wildly between major versions; specifying\n * different types (even optional types) here can cause issues with the build.\n *\n * This change was initially made for Next.js 15, which specifies the second\n * argument as `RouteContext`, whereas Next.js 13 and 14 omit it and Next.js 12\n * provides a `NextApiResponse`, which is varies based on the execution\n * environment used (edge vs serverless).\n */\nexport type RequestHandler = (\n  expectedReq: NextRequest,\n  res: unknown,\n) => Promise<Response>;\n\nconst isRecord = (val: unknown): val is Record<string, unknown> => {\n  return typeof val === \"object\" && val !== null;\n};\n\nconst isFunction = (val: unknown): val is (...args: unknown[]) => unknown => {\n  return typeof val === \"function\";\n};\n\nconst isNext12ApiResponse = (val: unknown): val is NextApiResponse => {\n  return (\n    isRecord(val) &&\n    isFunction(val.setHeader) &&\n    isFunction(val.status) &&\n    isFunction(val.send)\n  );\n};\n\n/**\n * In Next.js, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): RequestHandler & {\n  GET: RequestHandler;\n  POST: RequestHandler;\n  PUT: RequestHandler;\n} => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (\n      reqMethod: \"GET\" | \"POST\" | \"PUT\" | undefined,\n      ...args: Parameters<RequestHandler>\n    ) => {\n      const [expectedReq, res] = args;\n      const req = expectedReq as Either<NextApiRequest, NextRequest>;\n\n      const getHeader = (key: string): string | null | undefined => {\n        const header =\n          typeof req.headers.get === \"function\"\n            ? req.headers.get(key)\n            : req.headers[key];\n\n        return Array.isArray(header) ? header[0] : header;\n      };\n\n      return {\n        body: () => (typeof req.json === \"function\" ? req.json() : req.body),\n        headers: getHeader,\n        method: () => {\n          /**\n           * `req.method`, though types say otherwise, is not available in Next.js\n           * 13 {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}.\n           *\n           * Therefore, we must try to set the method ourselves where we know it.\n           */\n          const method = reqMethod || req.method || \"\";\n          return method;\n        },\n        isProduction: () => {\n          /**\n           * Vercel Edge Functions do not allow dynamic access to environment\n           * variables, so we'll manage production checks directly here.\n           *\n           * We try/catch to avoid situations where Next.js is being used in\n           * environments where `process.env` is not accessible or polyfilled.\n           */\n          try {\n            const isProd = process.env.NODE_ENV === \"production\";\n            return isProd;\n          } catch (_err) {\n            // no-op\n          }\n\n          return;\n        },\n        queryString: (key, url) => {\n          const qs = req.query?.[key] || url.searchParams.get(key);\n          return Array.isArray(qs) ? qs[0] : qs;\n        },\n\n        url: () => {\n          let absoluteUrl: URL | undefined;\n          try {\n            absoluteUrl = new URL(req.url as string);\n          } catch {\n            // no-op\n          }\n\n          if (absoluteUrl) {\n            /**\n             * `req.url` here should may be the full URL, including query string.\n             * There are some caveats, however, where Next.js will obfuscate\n             * the host. For example, in the case of `host.docker.internal`,\n             * Next.js will instead set the host here to `localhost`.\n             *\n             * To avoid this, we'll try to parse the URL from `req.url`, but\n             * also use the `host` header if it's available.\n             */\n            const host = options.serveHost || getHeader(\"host\");\n            if (host) {\n              const hostWithProtocol = new URL(\n                host.includes(\"://\")\n                  ? host\n                  : `${absoluteUrl.protocol}//${host}`,\n              );\n\n              absoluteUrl.protocol = hostWithProtocol.protocol;\n              absoluteUrl.host = hostWithProtocol.host;\n              absoluteUrl.port = hostWithProtocol.port;\n              absoluteUrl.username = hostWithProtocol.username;\n              absoluteUrl.password = hostWithProtocol.password;\n            }\n\n            return absoluteUrl;\n          }\n\n          let scheme: \"http\" | \"https\" = \"https\";\n          const host = options.serveHost || getHeader(\"host\") || \"\";\n\n          try {\n            if (process.env.NODE_ENV === \"development\") {\n              scheme = \"http\";\n            }\n          } catch (_err) {\n            // no-op\n          }\n\n          const url = new URL(req.url as string, `${scheme}://${host}`);\n\n          return url;\n        },\n        transformResponse: ({ body, headers, status }): Response => {\n          /**\n           * Carefully attempt to set headers and data on the response object\n           * for Next.js 12 support.\n           *\n           * This also assumes that we're not using Next.js 15, where the `res`\n           * object is repopulated as a `RouteContext` object. We expect these\n           * methods to NOT be defined in Next.js 15.\n           *\n           * We could likely use `instanceof ServerResponse` to better check the\n           * type of this, though Next.js 12 had issues with this due to not\n           * instantiating the response correctly.\n           */\n          if (isNext12ApiResponse(res)) {\n            for (const [key, value] of Object.entries(headers)) {\n              res.setHeader(key, value);\n            }\n\n            res.status(status);\n            res.send(body);\n\n            /**\n             * If we're here, we're in a serverless endpoint (not edge), so\n             * we've correctly sent the response and can return `undefined`.\n             *\n             * Next.js 13 edge requires that the return value is typed as\n             * `Response`, so we still enforce that as we cannot dynamically\n             * adjust typing based on the environment.\n             */\n            return undefined as unknown as Response;\n          }\n\n          /**\n           * If we're here, we're in an edge environment and need to return a\n           * `Response` object.\n           *\n           * We also don't know if the current environment has a native\n           * `Response` object, so we'll grab that first.\n           */\n          const Res = getResponse();\n          return new Res(body, { status, headers });\n        },\n        transformStreamingResponse: ({ body, headers, status }) => {\n          return new Response(body, { status, headers });\n        },\n      };\n    },\n  });\n\n  /**\n   * Next.js 13 uses\n   * {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}\n   * to declare API routes instead of a generic catch-all method that was\n   * available using the `pages/api` directory.\n   *\n   * This means that users must now export a function for each method supported\n   * by the endpoint. For us, this means requiring a user explicitly exports\n   * `GET`, `POST`, and `PUT` functions.\n   *\n   * Because of this, we'll add circular references to those property names of\n   * the returned handler, meaning we can write some succinct code to export\n   * them. Thanks, @goodoldneon.\n   *\n   * @example\n   * ```ts\n   * export const { GET, POST, PUT } = serve(...);\n   * ```\n   *\n   * See {@link https://beta.nextjs.org/docs/routing/route-handlers}\n   */\n  const baseFn = handler.createHandler();\n\n  const fn = baseFn.bind(null, undefined);\n\n  /**\n   * Ensure we have a non-variadic length to avoid issues with forced type\n   * checking.\n   */\n  Object.defineProperty(fn, \"length\", { value: 1 });\n\n  type Fn = typeof fn;\n\n  const handlerFn = Object.defineProperties(fn, {\n    GET: { value: baseFn.bind(null, \"GET\") },\n    POST: { value: baseFn.bind(null, \"POST\") },\n    PUT: { value: baseFn.bind(null, \"PUT\") },\n  }) as Fn & {\n    GET: Fn;\n    POST: Fn;\n    PUT: Fn;\n  };\n\n  return handlerFn;\n};\n"],"mappings":";;;;;;;;AAoCA,MAAaA,gBAAwC;AAmBrD,MAAM,YAAY,QAAiD;AACjE,QAAO,OAAO,QAAQ,YAAY,QAAQ;;AAG5C,MAAM,cAAc,QAAyD;AAC3E,QAAO,OAAO,QAAQ;;AAGxB,MAAM,uBAAuB,QAAyC;AACpE,QACE,SAAS,IAAI,IACb,WAAW,IAAI,UAAU,IACzB,WAAW,IAAI,OAAO,IACtB,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;AA0BxB,MAAa,SACX,YAKG;;;;;;;;;;;;;;;;;;;;;;CAgLH,MAAM,SA/KU,IAAI,mBAAmB;EACrC;EACA,GAAG;EACH,UACE,WACA,GAAG,SACA;GACH,MAAM,CAAC,aAAa,OAAO;GAC3B,MAAM,MAAM;GAEZ,MAAM,aAAa,QAA2C;IAC5D,MAAM,SACJ,OAAO,IAAI,QAAQ,QAAQ,aACvB,IAAI,QAAQ,IAAI,IAAI,GACpB,IAAI,QAAQ;AAElB,WAAO,MAAM,QAAQ,OAAO,GAAG,OAAO,KAAK;;AAG7C,UAAO;IACL,YAAa,OAAO,IAAI,SAAS,aAAa,IAAI,MAAM,GAAG,IAAI;IAC/D,SAAS;IACT,cAAc;AAQZ,YADe,aAAa,IAAI,UAAU;;IAG5C,oBAAoB;;;;;;;;AAQlB,SAAI;AAEF,aADe,QAAQ,IAAI,aAAa;cAEjC,MAAM;;IAMjB,cAAc,KAAK,QAAQ;KACzB,MAAM,KAAK,IAAI,QAAQ,QAAQ,IAAI,aAAa,IAAI,IAAI;AACxD,YAAO,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK;;IAGrC,WAAW;KACT,IAAIC;AACJ,SAAI;AACF,oBAAc,IAAI,IAAI,IAAI,IAAc;aAClC;AAIR,SAAI,aAAa;;;;;;;;;;MAUf,MAAMC,SAAO,QAAQ,aAAa,UAAU,OAAO;AACnD,UAAIA,QAAM;OACR,MAAM,mBAAmB,IAAI,IAC3BA,OAAK,SAAS,MAAM,GAChBA,SACA,GAAG,YAAY,SAAS,IAAIA,SACjC;AAED,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,WAAW,iBAAiB;;AAG1C,aAAO;;KAGT,IAAIC,SAA2B;KAC/B,MAAM,OAAO,QAAQ,aAAa,UAAU,OAAO,IAAI;AAEvD,SAAI;AACF,UAAI,QAAQ,IAAI,aAAa,cAC3B,UAAS;cAEJ,MAAM;AAMf,YAFY,IAAI,IAAI,IAAI,KAAe,GAAG,OAAO,KAAK,OAAO;;IAI/D,oBAAoB,EAAE,MAAM,SAAS,aAAuB;;;;;;;;;;;;;AAa1D,SAAI,oBAAoB,IAAI,EAAE;AAC5B,WAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,UAAU,KAAK,MAAM;AAG3B,UAAI,OAAO,OAAO;AAClB,UAAI,KAAK,KAAK;;;;;;;;;AAUd;;AAWF,YAAO,KADK,aAAa,EACV,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAE3C,6BAA6B,EAAE,MAAM,SAAS,aAAa;AACzD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEjD;;EAEJ,CAAC,CAuBqB,eAAe;CAEtC,MAAM,KAAK,OAAO,KAAK,MAAM,OAAU;;;;;AAMvC,QAAO,eAAe,IAAI,UAAU,EAAE,OAAO,GAAG,CAAC;AAcjD,QAVkB,OAAO,iBAAiB,IAAI;EAC5C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACxC,MAAM,EAAE,OAAO,OAAO,KAAK,MAAM,OAAO,EAAE;EAC1C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACzC,CAAC"}
+{"version":3,"file":"next.js","names":["frameworkName: SupportedFrameworkName","absoluteUrl: URL | undefined","host","scheme: \"http\" | \"https\""],"sources":["../src/next.ts"],"sourcesContent":["/**\n * An adapter for Next.js to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @module\n */\n\nimport type { NextApiRequest, NextApiResponse } from \"next\";\nimport type { NextRequest } from \"next/server\";\nimport {\n  InngestCommHandler,\n  type ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { getResponse } from \"./helpers/env.ts\";\nimport type { Either } from \"./helpers/types.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nextjs\";\n\n/**\n * The shape of a request handler, supporting Next.js 12+.\n *\n * We are intentionally abstract with the arguments here, as Next.js's type\n * checking when building varies wildly between major versions; specifying\n * different types (even optional types) here can cause issues with the build.\n *\n * This change was initially made for Next.js 15, which specifies the second\n * argument as `RouteContext`, whereas Next.js 13 and 14 omit it and Next.js 12\n * provides a `NextApiResponse`, which is varies based on the execution\n * environment used (edge vs serverless).\n */\nexport type RequestHandler = (\n  expectedReq: NextRequest,\n  res: unknown,\n) => Promise<Response>;\n\nconst isRecord = (val: unknown): val is Record<string, unknown> => {\n  return typeof val === \"object\" && val !== null;\n};\n\nconst isFunction = (val: unknown): val is (...args: unknown[]) => unknown => {\n  return typeof val === \"function\";\n};\n\nconst isNext12ApiResponse = (val: unknown): val is NextApiResponse => {\n  return (\n    isRecord(val) &&\n    isFunction(val.setHeader) &&\n    isFunction(val.status) &&\n    isFunction(val.send)\n  );\n};\n\n/**\n * In Next.js, serve and register any declared functions with Inngest, making\n * them available to be triggered by events.\n *\n * Supports Next.js 12+, both serverless and edge.\n *\n * @example Next.js <=12 or the pages router can export the handler directly\n * ```ts\n * export default serve({ client: inngest, functions: [fn1, fn2] });\n * ```\n *\n * @example Next.js >=13 with the `app` dir must export individual methods\n * ```ts\n * export const { GET, POST, PUT } = serve({\n *            client: inngest,\n *            functions: [fn1, fn2],\n * });\n * ```\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): RequestHandler & {\n  GET: RequestHandler;\n  POST: RequestHandler;\n  PUT: RequestHandler;\n} => {\n  const handler = new InngestCommHandler({\n    frameworkName,\n    ...options,\n    handler: (\n      reqMethod: \"GET\" | \"POST\" | \"PUT\" | undefined,\n      ...args: Parameters<RequestHandler>\n    ) => {\n      const [expectedReq, res] = args;\n      const req = expectedReq as Either<NextApiRequest, NextRequest>;\n\n      const getHeader = (key: string): string | null | undefined => {\n        const header =\n          typeof req.headers.get === \"function\"\n            ? req.headers.get(key)\n            : req.headers[key];\n\n        return Array.isArray(header) ? header[0] : header;\n      };\n\n      return {\n        body: async () => {\n          if (typeof req.json === \"function\") {\n            return await req.json();\n          }\n\n          if (req.body instanceof ReadableStream) {\n            return await streamToJSON(req.body);\n          }\n\n          return req.body;\n        },\n        headers: getHeader,\n        method: () => {\n          /**\n           * `req.method`, though types say otherwise, is not available in Next.js\n           * 13 {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}.\n           *\n           * Therefore, we must try to set the method ourselves where we know it.\n           */\n          const method = reqMethod || req.method || \"\";\n          return method;\n        },\n        isProduction: () => {\n          /**\n           * Vercel Edge Functions do not allow dynamic access to environment\n           * variables, so we'll manage production checks directly here.\n           *\n           * We try/catch to avoid situations where Next.js is being used in\n           * environments where `process.env` is not accessible or polyfilled.\n           */\n          try {\n            const isProd = process.env.NODE_ENV === \"production\";\n            return isProd;\n          } catch (_err) {\n            // no-op\n          }\n\n          return;\n        },\n        queryString: (key, url) => {\n          const qs = req.query?.[key] || url.searchParams.get(key);\n          return Array.isArray(qs) ? qs[0] : qs;\n        },\n\n        url: () => {\n          let absoluteUrl: URL | undefined;\n          try {\n            absoluteUrl = new URL(req.url as string);\n          } catch {\n            // no-op\n          }\n\n          if (absoluteUrl) {\n            /**\n             * `req.url` here should may be the full URL, including query string.\n             * There are some caveats, however, where Next.js will obfuscate\n             * the host. For example, in the case of `host.docker.internal`,\n             * Next.js will instead set the host here to `localhost`.\n             *\n             * To avoid this, we'll try to parse the URL from `req.url`, but\n             * also use the `host` header if it's available.\n             */\n            const host = options.serveHost || getHeader(\"host\");\n            if (host) {\n              const hostWithProtocol = new URL(\n                host.includes(\"://\")\n                  ? host\n                  : `${absoluteUrl.protocol}//${host}`,\n              );\n\n              absoluteUrl.protocol = hostWithProtocol.protocol;\n              absoluteUrl.host = hostWithProtocol.host;\n              absoluteUrl.port = hostWithProtocol.port;\n              absoluteUrl.username = hostWithProtocol.username;\n              absoluteUrl.password = hostWithProtocol.password;\n            }\n\n            return absoluteUrl;\n          }\n\n          let scheme: \"http\" | \"https\" = \"https\";\n          const host = options.serveHost || getHeader(\"host\") || \"\";\n\n          try {\n            if (process.env.NODE_ENV === \"development\") {\n              scheme = \"http\";\n            }\n          } catch (_err) {\n            // no-op\n          }\n\n          const url = new URL(req.url as string, `${scheme}://${host}`);\n\n          return url;\n        },\n        transformResponse: ({ body, headers, status }): Response => {\n          /**\n           * Carefully attempt to set headers and data on the response object\n           * for Next.js 12 support.\n           *\n           * This also assumes that we're not using Next.js 15, where the `res`\n           * object is repopulated as a `RouteContext` object. We expect these\n           * methods to NOT be defined in Next.js 15.\n           *\n           * We could likely use `instanceof ServerResponse` to better check the\n           * type of this, though Next.js 12 had issues with this due to not\n           * instantiating the response correctly.\n           */\n          if (isNext12ApiResponse(res)) {\n            for (const [key, value] of Object.entries(headers)) {\n              res.setHeader(key, value);\n            }\n\n            res.status(status);\n            res.send(body);\n\n            /**\n             * If we're here, we're in a serverless endpoint (not edge), so\n             * we've correctly sent the response and can return `undefined`.\n             *\n             * Next.js 13 edge requires that the return value is typed as\n             * `Response`, so we still enforce that as we cannot dynamically\n             * adjust typing based on the environment.\n             */\n            return undefined as unknown as Response;\n          }\n\n          /**\n           * If we're here, we're in an edge environment and need to return a\n           * `Response` object.\n           *\n           * We also don't know if the current environment has a native\n           * `Response` object, so we'll grab that first.\n           */\n          const Res = getResponse();\n          return new Res(body, { status, headers });\n        },\n        transformStreamingResponse: ({ body, headers, status }) => {\n          return new Response(body, { status, headers });\n        },\n      };\n    },\n  });\n\n  /**\n   * Next.js 13 uses\n   * {@link https://beta.nextjs.org/docs/routing/route-handlers Route Handlers}\n   * to declare API routes instead of a generic catch-all method that was\n   * available using the `pages/api` directory.\n   *\n   * This means that users must now export a function for each method supported\n   * by the endpoint. For us, this means requiring a user explicitly exports\n   * `GET`, `POST`, and `PUT` functions.\n   *\n   * Because of this, we'll add circular references to those property names of\n   * the returned handler, meaning we can write some succinct code to export\n   * them. Thanks, @goodoldneon.\n   *\n   * @example\n   * ```ts\n   * export const { GET, POST, PUT } = serve(...);\n   * ```\n   *\n   * See {@link https://beta.nextjs.org/docs/routing/route-handlers}\n   */\n  const baseFn = handler.createHandler();\n\n  const fn = baseFn.bind(null, undefined);\n\n  /**\n   * Ensure we have a non-variadic length to avoid issues with forced type\n   * checking.\n   */\n  Object.defineProperty(fn, \"length\", { value: 1 });\n\n  type Fn = typeof fn;\n\n  const handlerFn = Object.defineProperties(fn, {\n    GET: { value: baseFn.bind(null, \"GET\") },\n    POST: { value: baseFn.bind(null, \"POST\") },\n    PUT: { value: baseFn.bind(null, \"PUT\") },\n  }) as Fn & {\n    GET: Fn;\n    POST: Fn;\n    PUT: Fn;\n  };\n\n  return handlerFn;\n};\n\nasync function streamToJSON(stream: ReadableStream): Promise<unknown> {\n  const chunks = [];\n  const reader = stream.getReader();\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n  }\n  return JSON.parse(Buffer.concat(chunks).toString(\"utf8\"));\n}\n"],"mappings":";;;;;;;;AAoCA,MAAaA,gBAAwC;AAmBrD,MAAM,YAAY,QAAiD;AACjE,QAAO,OAAO,QAAQ,YAAY,QAAQ;;AAG5C,MAAM,cAAc,QAAyD;AAC3E,QAAO,OAAO,QAAQ;;AAGxB,MAAM,uBAAuB,QAAyC;AACpE,QACE,SAAS,IAAI,IACb,WAAW,IAAI,UAAU,IACzB,WAAW,IAAI,OAAO,IACtB,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;AA0BxB,MAAa,SACX,YAKG;;;;;;;;;;;;;;;;;;;;;;CA0LH,MAAM,SAzLU,IAAI,mBAAmB;EACrC;EACA,GAAG;EACH,UACE,WACA,GAAG,SACA;GACH,MAAM,CAAC,aAAa,OAAO;GAC3B,MAAM,MAAM;GAEZ,MAAM,aAAa,QAA2C;IAC5D,MAAM,SACJ,OAAO,IAAI,QAAQ,QAAQ,aACvB,IAAI,QAAQ,IAAI,IAAI,GACpB,IAAI,QAAQ;AAElB,WAAO,MAAM,QAAQ,OAAO,GAAG,OAAO,KAAK;;AAG7C,UAAO;IACL,MAAM,YAAY;AAChB,SAAI,OAAO,IAAI,SAAS,WACtB,QAAO,MAAM,IAAI,MAAM;AAGzB,SAAI,IAAI,gBAAgB,eACtB,QAAO,MAAM,aAAa,IAAI,KAAK;AAGrC,YAAO,IAAI;;IAEb,SAAS;IACT,cAAc;AAQZ,YADe,aAAa,IAAI,UAAU;;IAG5C,oBAAoB;;;;;;;;AAQlB,SAAI;AAEF,aADe,QAAQ,IAAI,aAAa;cAEjC,MAAM;;IAMjB,cAAc,KAAK,QAAQ;KACzB,MAAM,KAAK,IAAI,QAAQ,QAAQ,IAAI,aAAa,IAAI,IAAI;AACxD,YAAO,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK;;IAGrC,WAAW;KACT,IAAIC;AACJ,SAAI;AACF,oBAAc,IAAI,IAAI,IAAI,IAAc;aAClC;AAIR,SAAI,aAAa;;;;;;;;;;MAUf,MAAMC,SAAO,QAAQ,aAAa,UAAU,OAAO;AACnD,UAAIA,QAAM;OACR,MAAM,mBAAmB,IAAI,IAC3BA,OAAK,SAAS,MAAM,GAChBA,SACA,GAAG,YAAY,SAAS,IAAIA,SACjC;AAED,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,OAAO,iBAAiB;AACpC,mBAAY,WAAW,iBAAiB;AACxC,mBAAY,WAAW,iBAAiB;;AAG1C,aAAO;;KAGT,IAAIC,SAA2B;KAC/B,MAAM,OAAO,QAAQ,aAAa,UAAU,OAAO,IAAI;AAEvD,SAAI;AACF,UAAI,QAAQ,IAAI,aAAa,cAC3B,UAAS;cAEJ,MAAM;AAMf,YAFY,IAAI,IAAI,IAAI,KAAe,GAAG,OAAO,KAAK,OAAO;;IAI/D,oBAAoB,EAAE,MAAM,SAAS,aAAuB;;;;;;;;;;;;;AAa1D,SAAI,oBAAoB,IAAI,EAAE;AAC5B,WAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,UAAU,KAAK,MAAM;AAG3B,UAAI,OAAO,OAAO;AAClB,UAAI,KAAK,KAAK;;;;;;;;;AAUd;;AAWF,YAAO,KADK,aAAa,EACV,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAE3C,6BAA6B,EAAE,MAAM,SAAS,aAAa;AACzD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEjD;;EAEJ,CAAC,CAuBqB,eAAe;CAEtC,MAAM,KAAK,OAAO,KAAK,MAAM,OAAU;;;;;AAMvC,QAAO,eAAe,IAAI,UAAU,EAAE,OAAO,GAAG,CAAC;AAcjD,QAVkB,OAAO,iBAAiB,IAAI;EAC5C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACxC,MAAM,EAAE,OAAO,OAAO,KAAK,MAAM,OAAO,EAAE;EAC1C,KAAK,EAAE,OAAO,OAAO,KAAK,MAAM,MAAM,EAAE;EACzC,CAAC;;AASJ,eAAe,aAAa,QAA0C;CACpE,MAAM,SAAS,EAAE;CACjB,MAAM,SAAS,OAAO,WAAW;AACjC,QAAO,MAAM;EACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,MAAI,KACF;AAEF,SAAO,KAAK,MAAM;;AAEpB,QAAO,KAAK,MAAM,OAAO,OAAO,OAAO,CAAC,SAAS,OAAO,CAAC"}

package/nitro.cjs

@@ -18,42 +18,8 @@ const serve = (options) => {
 		frameworkName
 	});
 };
-/**
-* In Nitro, create a function that can define an event handler with Inngest
-* steps enabled, allowing you to use steps seamlessly within that API.
-*
-* @example
-* ```ts
-* import { Inngest, step } from "inngest";
-* import { createExperimentalEndpointWrapper } from "inngest/nitro";
-*
-* const inngestEventHandler = createExperimentalEndpointWrapper({
-*   client: new Inngest({ id: "nitro-sync-example" }),
-* });
-*
-*
-* export default inngestEventHandler(async (event) => {
-*   const foo = await step.run("example/step", async () => {
-*     return "Hello from step!";
-*   });
-*
-*   return `
-*       <meta charset="utf-8">
-*       <h1>This endpoint worked!</h1>
-*       <p>The step's result was: ${foo}</p>
-*     `;
-* });
-* ```
-*/
-const createExperimentalEndpointWrapper = (options) => {
-	return require_h3.createExperimentalEndpointWrapper({
-		...options,
-		frameworkName
-	});
-};
 
 //#endregion
-exports.createExperimentalEndpointWrapper = createExperimentalEndpointWrapper;
 exports.frameworkName = frameworkName;
 exports.serve = serve;
 //# sourceMappingURL=nitro.cjs.map

package/nitro.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"nitro.cjs","names":["frameworkName: SupportedFrameworkName","serveH3","createExperimentalEndpointWrapperH3"],"sources":["../src/nitro.ts"],"sourcesContent":["/**\n * An adapter for Nitro to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * @module\n */\n\nimport type {\n  InternalServeHandlerOptions,\n  ServeHandlerOptions,\n  SyncHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport {\n  createExperimentalEndpointWrapper as createExperimentalEndpointWrapperH3,\n  serve as serveH3,\n} from \"./h3.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nitro\";\n\n/**\n * In Nitro, serve and register any declared functions with Inngest, making them\n * available to be triggered by events.\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ReturnType<typeof serveH3> => {\n  const optsOverrides: InternalServeHandlerOptions = {\n    ...options,\n    frameworkName,\n  };\n\n  return serveH3(optsOverrides);\n};\n\n/**\n * In Nitro, create a function that can define an event handler with Inngest\n * steps enabled, allowing you to use steps seamlessly within that API.\n *\n * @example\n * ```ts\n * import { Inngest, step } from \"inngest\";\n * import { createExperimentalEndpointWrapper } from \"inngest/nitro\";\n *\n * const inngestEventHandler = createExperimentalEndpointWrapper({\n *   client: new Inngest({ id: \"nitro-sync-example\" }),\n * });\n *\n *\n * export default inngestEventHandler(async (event) => {\n *   const foo = await step.run(\"example/step\", async () => {\n *     return \"Hello from step!\";\n *   });\n *\n *   return `\n *       <meta charset=\"utf-8\">\n *       <h1>This endpoint worked!</h1>\n *       <p>The step's result was: ${foo}</p>\n *     `;\n * });\n * ```\n */\nexport const createExperimentalEndpointWrapper = (\n  options: SyncHandlerOptions,\n) => {\n  const optsOverrides = {\n    ...options,\n    frameworkName,\n  };\n\n  return createExperimentalEndpointWrapperH3(optsOverrides);\n};\n"],"mappings":";;;;;;;AAsBA,MAAaA,gBAAwC;;;;;;;AASrD,MAAa,SACX,YAC+B;AAM/B,QAAOC,iBAL4C;EACjD,GAAG;EACH;EACD,CAE4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/B,MAAa,qCACX,YACG;AAMH,QAAOC,6CALe;EACpB,GAAG;EACH;EACD,CAEwD"}
+{"version":3,"file":"nitro.cjs","names":["frameworkName: SupportedFrameworkName","serveH3"],"sources":["../src/nitro.ts"],"sourcesContent":["/**\n * An adapter for Nitro to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * @module\n */\n\nimport type {\n  InternalServeHandlerOptions,\n  ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { serve as serveH3 } from \"./h3.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nitro\";\n\n/**\n * In Nitro, serve and register any declared functions with Inngest, making them\n * available to be triggered by events.\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ReturnType<typeof serveH3> => {\n  const optsOverrides: InternalServeHandlerOptions = {\n    ...options,\n    frameworkName,\n  };\n\n  return serveH3(optsOverrides);\n};\n"],"mappings":";;;;;;;AAkBA,MAAaA,gBAAwC;;;;;;;AASrD,MAAa,SACX,YAC+B;AAM/B,QAAOC,iBAL4C;EACjD,GAAG;EACH;EACD,CAE4B"}

package/nitro.d.cts

@@ -1,7 +1,6 @@
 import { SupportedFrameworkName } from "./types.cjs";
-import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.cjs";
+import { ServeHandlerOptions } from "./components/InngestCommHandler.cjs";
 import { serve as serve$1 } from "./h3.cjs";
-import * as h30 from "h3";
 
 //#region src/nitro.d.ts
 
@@ -17,34 +16,6 @@ declare const frameworkName: SupportedFrameworkName;
  * @public
  */
 declare const serve: (options: ServeHandlerOptions) => ReturnType<typeof serve$1>;
-/**
- * In Nitro, create a function that can define an event handler with Inngest
- * steps enabled, allowing you to use steps seamlessly within that API.
- *
- * @example
- * ```ts
- * import { Inngest, step } from "inngest";
- * import { createExperimentalEndpointWrapper } from "inngest/nitro";
- *
- * const inngestEventHandler = createExperimentalEndpointWrapper({
- *   client: new Inngest({ id: "nitro-sync-example" }),
- * });
- *
- *
- * export default inngestEventHandler(async (event) => {
- *   const foo = await step.run("example/step", async () => {
- *     return "Hello from step!";
- *   });
- *
- *   return `
- *       <meta charset="utf-8">
- *       <h1>This endpoint worked!</h1>
- *       <p>The step's result was: ${foo}</p>
- *     `;
- * });
- * ```
- */
-declare const createExperimentalEndpointWrapper: (options: SyncHandlerOptions) => (handler: (event: h30.H3Event<h30.EventHandlerRequest>) => Promise<any>) => (event: h30.H3Event<h30.EventHandlerRequest>) => Promise<any>;
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=nitro.d.cts.map

package/nitro.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro.d.cts","names":[],"sources":["../src/nitro.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAqEa,cA/CA,aA+CA,EA/Ce,sBAwD3B;;;;;;;AAR4B,cAvChB,KAuCgB,EAAA,CAAA,OAAA,EAtClB,mBAsCkB,EAAA,GArC1B,UAqC0B,CAAA,OArCR,OAqCQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cADhB,6CACF,yCAAkB,GAAA,CAAA,QAAA,GAAA,CAAA,mBAAA,MAAA,yBAAA,GAAA,CAAA,QAAA,GAAA,CAAA,mBAAA,MAAA"}
+{"version":3,"file":"nitro.d.cts","names":[],"sources":["../src/nitro.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAkBa,eAAe;;;;;;;cASf,iBACF,wBACR,kBAAkB"}

package/nitro.d.ts

@@ -1,7 +1,6 @@
 import { SupportedFrameworkName } from "./types.js";
-import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.js";
+import { ServeHandlerOptions } from "./components/InngestCommHandler.js";
 import { serve as serve$1 } from "./h3.js";
-import * as h30 from "h3";
 
 //#region src/nitro.d.ts
 
@@ -17,34 +16,6 @@ declare const frameworkName: SupportedFrameworkName;
  * @public
  */
 declare const serve: (options: ServeHandlerOptions) => ReturnType<typeof serve$1>;
-/**
- * In Nitro, create a function that can define an event handler with Inngest
- * steps enabled, allowing you to use steps seamlessly within that API.
- *
- * @example
- * ```ts
- * import { Inngest, step } from "inngest";
- * import { createExperimentalEndpointWrapper } from "inngest/nitro";
- *
- * const inngestEventHandler = createExperimentalEndpointWrapper({
- *   client: new Inngest({ id: "nitro-sync-example" }),
- * });
- *
- *
- * export default inngestEventHandler(async (event) => {
- *   const foo = await step.run("example/step", async () => {
- *     return "Hello from step!";
- *   });
- *
- *   return `
- *       <meta charset="utf-8">
- *       <h1>This endpoint worked!</h1>
- *       <p>The step's result was: ${foo}</p>
- *     `;
- * });
- * ```
- */
-declare const createExperimentalEndpointWrapper: (options: SyncHandlerOptions) => (handler: (event: h30.H3Event<h30.EventHandlerRequest>) => Promise<any>) => (event: h30.H3Event<h30.EventHandlerRequest>) => Promise<any>;
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=nitro.d.ts.map

package/nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro.d.ts","names":[],"sources":["../src/nitro.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAqEa,cA/CA,aA+CA,EA/Ce,sBAwD3B;;;;;;;AAR4B,cAvChB,KAuCgB,EAAA,CAAA,OAAA,EAtClB,mBAsCkB,EAAA,GArC1B,UAqC0B,CAAA,OArCR,OAqCQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cADhB,6CACF,yCAAkB,GAAA,CAAA,QAAA,GAAA,CAAA,mBAAA,MAAA,yBAAA,GAAA,CAAA,QAAA,GAAA,CAAA,mBAAA,MAAA"}
+{"version":3,"file":"nitro.d.ts","names":[],"sources":["../src/nitro.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAkBa,eAAe;;;;;;;cASf,iBACF,wBACR,kBAAkB"}

package/nitro.js

@@ -1,4 +1,4 @@
-import { createExperimentalEndpointWrapper as createExperimentalEndpointWrapper$1, serve as serve$1 } from "./h3.js";
+import { serve as serve$1 } from "./h3.js";
 
 //#region src/nitro.ts
 /**
@@ -18,40 +18,7 @@ const serve = (options) => {
 		frameworkName
 	});
 };
-/**
-* In Nitro, create a function that can define an event handler with Inngest
-* steps enabled, allowing you to use steps seamlessly within that API.
-*
-* @example
-* ```ts
-* import { Inngest, step } from "inngest";
-* import { createExperimentalEndpointWrapper } from "inngest/nitro";
-*
-* const inngestEventHandler = createExperimentalEndpointWrapper({
-*   client: new Inngest({ id: "nitro-sync-example" }),
-* });
-*
-*
-* export default inngestEventHandler(async (event) => {
-*   const foo = await step.run("example/step", async () => {
-*     return "Hello from step!";
-*   });
-*
-*   return `
-*       <meta charset="utf-8">
-*       <h1>This endpoint worked!</h1>
-*       <p>The step's result was: ${foo}</p>
-*     `;
-* });
-* ```
-*/
-const createExperimentalEndpointWrapper = (options) => {
-	return createExperimentalEndpointWrapper$1({
-		...options,
-		frameworkName
-	});
-};
 
 //#endregion
-export { createExperimentalEndpointWrapper, frameworkName, serve };
+export { frameworkName, serve };
 //# sourceMappingURL=nitro.js.map

package/nitro.js.map

@@ -1 +1 @@
-{"version":3,"file":"nitro.js","names":["frameworkName: SupportedFrameworkName","serveH3","createExperimentalEndpointWrapperH3"],"sources":["../src/nitro.ts"],"sourcesContent":["/**\n * An adapter for Nitro to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * @module\n */\n\nimport type {\n  InternalServeHandlerOptions,\n  ServeHandlerOptions,\n  SyncHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport {\n  createExperimentalEndpointWrapper as createExperimentalEndpointWrapperH3,\n  serve as serveH3,\n} from \"./h3.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nitro\";\n\n/**\n * In Nitro, serve and register any declared functions with Inngest, making them\n * available to be triggered by events.\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ReturnType<typeof serveH3> => {\n  const optsOverrides: InternalServeHandlerOptions = {\n    ...options,\n    frameworkName,\n  };\n\n  return serveH3(optsOverrides);\n};\n\n/**\n * In Nitro, create a function that can define an event handler with Inngest\n * steps enabled, allowing you to use steps seamlessly within that API.\n *\n * @example\n * ```ts\n * import { Inngest, step } from \"inngest\";\n * import { createExperimentalEndpointWrapper } from \"inngest/nitro\";\n *\n * const inngestEventHandler = createExperimentalEndpointWrapper({\n *   client: new Inngest({ id: \"nitro-sync-example\" }),\n * });\n *\n *\n * export default inngestEventHandler(async (event) => {\n *   const foo = await step.run(\"example/step\", async () => {\n *     return \"Hello from step!\";\n *   });\n *\n *   return `\n *       <meta charset=\"utf-8\">\n *       <h1>This endpoint worked!</h1>\n *       <p>The step's result was: ${foo}</p>\n *     `;\n * });\n * ```\n */\nexport const createExperimentalEndpointWrapper = (\n  options: SyncHandlerOptions,\n) => {\n  const optsOverrides = {\n    ...options,\n    frameworkName,\n  };\n\n  return createExperimentalEndpointWrapperH3(optsOverrides);\n};\n"],"mappings":";;;;;;;AAsBA,MAAaA,gBAAwC;;;;;;;AASrD,MAAa,SACX,YAC+B;AAM/B,QAAOC,QAL4C;EACjD,GAAG;EACH;EACD,CAE4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/B,MAAa,qCACX,YACG;AAMH,QAAOC,oCALe;EACpB,GAAG;EACH;EACD,CAEwD"}
+{"version":3,"file":"nitro.js","names":["frameworkName: SupportedFrameworkName","serveH3"],"sources":["../src/nitro.ts"],"sourcesContent":["/**\n * An adapter for Nitro to serve and register any declared functions with\n * Inngest, making them available to be triggered by events.\n *\n * @module\n */\n\nimport type {\n  InternalServeHandlerOptions,\n  ServeHandlerOptions,\n} from \"./components/InngestCommHandler.ts\";\nimport { serve as serveH3 } from \"./h3.ts\";\nimport type { SupportedFrameworkName } from \"./types.ts\";\n\n/**\n * The name of the framework, used to identify the framework in Inngest\n * dashboards and during testing.\n */\nexport const frameworkName: SupportedFrameworkName = \"nitro\";\n\n/**\n * In Nitro, serve and register any declared functions with Inngest, making them\n * available to be triggered by events.\n *\n * @public\n */\n// Has explicit return type to avoid JSR-defined \"slow types\"\nexport const serve = (\n  options: ServeHandlerOptions,\n): ReturnType<typeof serveH3> => {\n  const optsOverrides: InternalServeHandlerOptions = {\n    ...options,\n    frameworkName,\n  };\n\n  return serveH3(optsOverrides);\n};\n"],"mappings":";;;;;;;AAkBA,MAAaA,gBAAwC;;;;;;;AASrD,MAAa,SACX,YAC+B;AAM/B,QAAOC,QAL4C;EACjD,GAAG;EACH;EACD,CAE4B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inngest",
-  "version": "3.48.2-pr-1209.2",
+  "version": "3.49.1",
   "description": "Official SDK for Inngest.com. Inngest is the reliability layer for modern applications. Inngest combines durable execution, events, and queues into a zero-infra platform with built-in observability.",
   "main": "./index.cjs",
   "module": "./index.js",

package/types.d.cts

@@ -1234,12 +1234,12 @@ declare const functionConfigSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodEffects<z.ZodString, "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`, string>>;
   }, "strict", z.ZodTypeAny, {
     period: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`;
-    key?: string | undefined;
     timeout?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
+    key?: string | undefined;
   }, {
     period: string;
-    key?: string | undefined;
     timeout?: string | undefined;
+    key?: string | undefined;
   }>>;
   timeouts: z.ZodOptional<z.ZodObject<{
     start: z.ZodOptional<z.ZodEffects<z.ZodString, "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`, string>>;
@@ -1340,8 +1340,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`;
-    key?: string | undefined;
     timeout?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
+    key?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
@@ -1400,8 +1400,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: string;
-    key?: string | undefined;
     timeout?: string | undefined;
+    key?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: string | undefined;

package/types.d.ts

@@ -1234,12 +1234,12 @@ declare const functionConfigSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodEffects<z.ZodString, "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`, string>>;
   }, "strict", z.ZodTypeAny, {
     period: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`;
-    key?: string | undefined;
     timeout?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
+    key?: string | undefined;
   }, {
     period: string;
-    key?: string | undefined;
     timeout?: string | undefined;
+    key?: string | undefined;
   }>>;
   timeouts: z.ZodOptional<z.ZodObject<{
     start: z.ZodOptional<z.ZodEffects<z.ZodString, "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`, string>>;
@@ -1340,8 +1340,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s`;
-    key?: string | undefined;
     timeout?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
+    key?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: "" | `${number}w` | `${number}d` | `${number}h` | `${number}m` | `${number}s` | `${number}m${number}s` | `${number}h${number}s` | `${number}h${number}m` | `${number}h${number}m${number}s` | `${number}d${number}s` | `${number}d${number}m` | `${number}d${number}m${number}s` | `${number}d${number}h` | `${number}d${number}h${number}s` | `${number}d${number}h${number}m` | `${number}d${number}h${number}m${number}s` | `${number}w${number}s` | `${number}w${number}m` | `${number}w${number}m${number}s` | `${number}w${number}h` | `${number}w${number}h${number}s` | `${number}w${number}h${number}m` | `${number}w${number}h${number}m${number}s` | `${number}w${number}d` | `${number}w${number}d${number}s` | `${number}w${number}d${number}m` | `${number}w${number}d${number}m${number}s` | `${number}w${number}d${number}h` | `${number}w${number}d${number}h${number}s` | `${number}w${number}d${number}h${number}m` | `${number}w${number}d${number}h${number}m${number}s` | undefined;
@@ -1400,8 +1400,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: string;
-    key?: string | undefined;
     timeout?: string | undefined;
+    key?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: string | undefined;

package/version.cjs

@@ -1,6 +1,6 @@
 
 //#region src/version.ts
-const version = "3.48.2-pr-1209.2";
+const version = "3.49.1";
 
 //#endregion
 exports.version = version;

package/version.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"version.cjs","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.48.2-pr-1209.2\";\n"],"mappings":";;AACA,MAAa,UAAU"}
+{"version":3,"file":"version.cjs","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.49.1\";\n"],"mappings":";;AACA,MAAa,UAAU"}

package/version.d.cts

@@ -1,5 +1,5 @@
 //#region src/version.d.ts
-declare const version = "3.48.2-pr-1209.2";
+declare const version = "3.49.1";
 //#endregion
 export { version };
 //# sourceMappingURL=version.d.cts.map

package/version.d.ts

@@ -1,5 +1,5 @@
 //#region src/version.d.ts
-declare const version = "3.48.2-pr-1209.2";
+declare const version = "3.49.1";
 //#endregion
 export { version };
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 //#region src/version.ts
-const version = "3.48.2-pr-1209.2";
+const version = "3.49.1";
 
 //#endregion
 export { version };

package/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.48.2-pr-1209.2\";\n"],"mappings":";AACA,MAAa,UAAU"}
+{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.49.1\";\n"],"mappings":";AACA,MAAa,UAAU"}