inngest 3.48.1 → 3.48.2-pr-1209.1

package/h3.cjs

@@ -1,4 +1,5 @@
 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");
@@ -37,6 +38,50 @@ 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.
@@ -66,35 +111,45 @@ const frameworkName = "h3";
 * @public
 */
 const serve = (options) => {
-	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();
+	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;
 };
 
 //#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"],"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"}
+{"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"}

package/h3.d.cts

@@ -1,5 +1,5 @@
 import { SupportedFrameworkName } from "./types.cjs";
-import { ServeHandlerOptions } from "./components/InngestCommHandler.cjs";
+import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.cjs";
 import { EventHandlerRequest, H3Event } from "h3";
 
 //#region src/h3.d.ts
@@ -38,6 +38,34 @@ 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 { frameworkName, serve };
+export { createExperimentalEndpointWrapper, 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":";;;;;;;;;;cAiDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Bf,iBACF,iCACC,QAAQ,yBAAyB"}
+{"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"}

package/h3.d.ts

@@ -1,5 +1,5 @@
 import { SupportedFrameworkName } from "./types.js";
-import { ServeHandlerOptions } from "./components/InngestCommHandler.js";
+import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.js";
 import { EventHandlerRequest, H3Event } from "h3";
 
 //#region src/h3.d.ts
@@ -38,6 +38,34 @@ 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 { frameworkName, serve };
+export { createExperimentalEndpointWrapper, 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":";;;;;;;;;;cAiDa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Bf,iBACF,iCACC,QAAQ,yBAAyB"}
+{"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"}

package/h3.js

@@ -1,6 +1,7 @@
+import { stringify } from "./helpers/strings.js";
 import { processEnv } from "./helpers/env.js";
 import { InngestCommHandler } from "./components/InngestCommHandler.js";
-import { getHeader, getQuery, readBody, send, setHeaders } from "h3";
+import { defineEventHandler, getHeader, getQuery, getResponseHeaders, getResponseStatus, readBody, readRawBody, send, setHeaders } from "h3";
 
 //#region src/h3.ts
 /**
@@ -36,6 +37,50 @@ import { getHeader, getQuery, readBody, send, setHeaders } from "h3";
 * 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.
@@ -65,34 +110,43 @@ const frameworkName = "h3";
 * @public
 */
 const serve = (options) => {
-	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();
+	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;
 };
 
 //#endregion
-export { frameworkName, serve };
+export { createExperimentalEndpointWrapper, frameworkName, serve };
 //# sourceMappingURL=h3.js.map

package/h3.js.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/helpers/errors.js

@@ -2,7 +2,7 @@ import { __export } from "../_virtual/rolldown_runtime.js";
 import { NonRetriableError } from "../components/NonRetriableError.js";
 import { z } from "zod/v3";
 import chalk from "chalk";
-import stringify from "json-stringify-safe";
+import safeStringify from "json-stringify-safe";
 import { deserializeError, errorConstructors, serializeError } from "serialize-error-cjs";
 import stripAnsi from "strip-ansi";
 
@@ -60,7 +60,7 @@ const serializeError$1 = (subject, allowUnknown = false) => {
 			const ret = {
 				...serializedErr,
 				name: serializedErr.name || "Error",
-				message: serializedErr.message || stringify(subject) || "Unknown error; error serialization could not find a message.",
+				message: serializedErr.message || safeStringify(subject) || "Unknown error; error serialization could not find a message.",
 				stack: serializedErr.stack || "",
 				[SERIALIZED_KEY]: SERIALIZED_VALUE
 			};
@@ -80,7 +80,7 @@ const serializeError$1 = (subject, allowUnknown = false) => {
 		if (allowUnknown) return subject;
 		try {
 			return {
-				...serializeError$1(new Error(typeof subject === "string" ? subject : stringify(subject)), false),
+				...serializeError$1(new Error(typeof subject === "string" ? subject : safeStringify(subject)), false),
 				stack: "",
 				[SERIALIZED_KEY]: SERIALIZED_VALUE
 			};

package/helpers/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":["serializeError","cjsSerializeError","target: unknown","deserializeError","requiredFields: (keyof SerializedError)[]","cjsDeserializeError"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport stripAnsi from \"strip-ansi\";\nimport { z } from \"zod/v3\";\nimport type { Inngest } from \"../components/Inngest.ts\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n}\n\nexport interface PrettyError {\n  /**\n   * The type of message, used to decide on icon and color use.\n   */\n  type?: \"error\" | \"warn\";\n\n  /**\n   * A short, succinct description of what happened. Will be used as the error's\n   * header, so should be short and to the point with no trailing punctuation.\n   */\n  whatHappened: string;\n\n  /**\n   * If applicable, provide a full sentence to reassure the user about certain\n   * details, for example if an error occurred whilst uploading a file, but we\n   * can assure the user that uploading succeeded and something internal failed.\n   */\n  reassurance?: string;\n\n  /**\n   * Tell the user why the error happened if we can. This should be a full\n   * sentence or paragraph that explains the error in more detail, for example\n   * to explain that a file failed to upload because it was too large and that\n   * the maximum size is 10MB.\n   */\n  why?: string;\n\n  /**\n   * If applicable, tell the user what the consequences of the error are, for\n   * example to tell them that their file was not uploaded and that they will\n   * need to try again.\n   */\n  consequences?: string;\n\n  /**\n   * If we can, tell the user what they can do to fix the error now. This should\n   * be a full sentence or paragraph that explains what the user can do to fix\n   * the error, for example to tell them to try uploading a smaller file or\n   * upgrade to a paid plan.\n   */\n  toFixNow?: string | string[];\n\n  /**\n   * If applicable, tell the user what to do if the error persists, they want\n   * more information, or the fix we've given them doesn't work.\n   *\n   * This should be a full sentence or paragraph, and will likely refer users\n   * to contact us for support, join our Discord, or read documentation.\n   */\n  otherwise?: string;\n\n  /**\n   * Add a stack trace to the message so that the user knows what line of code\n   * the error is in relation to.\n   */\n  stack?: true;\n\n  /**\n   * If applicable, provide a code that the user can use to reference the error\n   * when contacting support.\n   */\n  code?: ErrCode;\n}\n\nexport const prettyErrorSplitter =\n  \"=================================================\";\n\n/**\n * Given an unknown `err`, mutate it to minify any pretty errors that it\n * contains.\n */\nexport const minifyPrettyError = <T>(err: T): T => {\n  try {\n    if (!isError(err)) {\n      return err;\n    }\n\n    const isPrettyError = err.message.includes(prettyErrorSplitter);\n    if (!isPrettyError) {\n      return err;\n    }\n\n    const sanitizedMessage = stripAnsi(err.message);\n\n    const message =\n      sanitizedMessage.split(\"  \")[1]?.split(\"\\n\")[0]?.trim() || err.message;\n    const code =\n      sanitizedMessage.split(\"\\n\\nCode: \")[1]?.split(\"\\n\\n\")[0]?.trim() ||\n      undefined;\n\n    err.message = [code, message].filter(Boolean).join(\" - \");\n\n    if (err.stack) {\n      const sanitizedStack = stripAnsi(err.stack);\n      const stackRest = sanitizedStack\n        .split(`${prettyErrorSplitter}\\n`)\n        .slice(2)\n        .join(\"\\n\");\n\n      err.stack = `${err.name}: ${err.message}\\n${stackRest}`;\n    }\n\n    return err;\n  } catch (_noopErr) {\n    return err;\n  }\n};\n\n/**\n * Given an `err`, return a boolean representing whether it is in the shape of\n * an `Error` or not.\n */\nconst isError = (err: unknown): err is Error => {\n  try {\n    if (err instanceof Error) {\n      return true;\n    }\n\n    if (typeof err !== \"object\" || err === null) {\n      return false;\n    }\n\n    const hasName = Object.hasOwn(err, \"name\");\n    const hasMessage = Object.hasOwn(err, \"message\");\n\n    return hasName && hasMessage;\n  } catch (_noopErr) {\n    return false;\n  }\n};\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\n/**\n * Given a {@link PrettyError}, return a nicely-formatted string ready to log\n * or throw.\n *\n * Useful for ensuring that errors are logged in a consistent, helpful format\n * across the SDK by prompting for key pieces of information.\n */\nexport const prettyError = ({\n  type = \"error\",\n  whatHappened,\n  otherwise,\n  reassurance,\n  toFixNow,\n  why,\n  consequences,\n  stack,\n  code,\n}: PrettyError): string => {\n  const { icon, colorFn } = (\n    {\n      error: { icon: \"❌\", colorFn: chalk.red },\n      warn: { icon: \"⚠️\", colorFn: chalk.yellow },\n    } satisfies Record<\n      NonNullable<PrettyError[\"type\"]>,\n      { icon: string; colorFn: (s: string) => string }\n    >\n  )[type];\n\n  let header = `${icon}  ${chalk.bold.underline(whatHappened.trim())}`;\n  if (stack) {\n    header +=\n      \"\\n\" +\n      [...(new Error().stack?.split(\"\\n\").slice(1).filter(Boolean) || [])].join(\n        \"\\n\",\n      );\n  }\n\n  let toFixNowStr =\n    (Array.isArray(toFixNow)\n      ? toFixNow\n          .map((s) => s.trim())\n          .filter(Boolean)\n          .map((s, i) => `\\t${i + 1}. ${s}`)\n          .join(\"\\n\")\n      : toFixNow?.trim()) ?? \"\";\n\n  if (Array.isArray(toFixNow) && toFixNowStr) {\n    toFixNowStr = `To fix this, you can take one of the following courses of action:\\n\\n${toFixNowStr}`;\n  }\n\n  let body = [reassurance?.trim(), why?.trim(), consequences?.trim()]\n    .filter(Boolean)\n    .join(\" \");\n  body += body ? `\\n\\n${toFixNowStr}` : toFixNowStr;\n\n  const trailer = [otherwise?.trim()].filter(Boolean).join(\" \");\n\n  const message = [\n    prettyErrorSplitter,\n    header,\n    body,\n    trailer,\n    code ? `Code: ${code}` : \"\",\n    prettyErrorSplitter,\n  ]\n    .filter(Boolean)\n    .join(\"\\n\\n\");\n\n  return colorFn(message);\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n  `Use \\`inngest.${\"setEventKey\" satisfies keyof Inngest.Any}()\\` at runtime`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: <explanation>\n      throw err;\n    }\n  };\n};\n\n/**\n * Legacy v0 execution error for functions that don't support mixing steps and\n * regular async actions.\n */\nexport const functionStoppedRunningErr = (code: ErrCode) => {\n  return prettyError({\n    whatHappened: \"Your function was stopped from running\",\n    why: \"We detected a mix of asynchronous logic, some using step tooling and some not.\",\n    consequences:\n      \"This can cause unexpected behaviour when a function is paused and resumed and is therefore strongly discouraged; we stopped your function to ensure nothing unexpected happened!\",\n    stack: true,\n    toFixNow:\n      \"Ensure that your function is either entirely step-based or entirely non-step-based, by either wrapping all asynchronous logic in `step.run()` calls or by removing all `step.*()` calls.\",\n    otherwise:\n      \"For more information on why step functions work in this manner, see https://www.inngest.com/docs/functions/multi-step#gotchas\",\n    code,\n  });\n};\n"],"mappings":"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"}
+{"version":3,"file":"errors.js","names":["serializeError","cjsSerializeError","stringify","target: unknown","deserializeError","requiredFields: (keyof SerializedError)[]","cjsDeserializeError"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport stripAnsi from \"strip-ansi\";\nimport { z } from \"zod/v3\";\nimport type { Inngest } from \"../components/Inngest.ts\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n}\n\nexport interface PrettyError {\n  /**\n   * The type of message, used to decide on icon and color use.\n   */\n  type?: \"error\" | \"warn\";\n\n  /**\n   * A short, succinct description of what happened. Will be used as the error's\n   * header, so should be short and to the point with no trailing punctuation.\n   */\n  whatHappened: string;\n\n  /**\n   * If applicable, provide a full sentence to reassure the user about certain\n   * details, for example if an error occurred whilst uploading a file, but we\n   * can assure the user that uploading succeeded and something internal failed.\n   */\n  reassurance?: string;\n\n  /**\n   * Tell the user why the error happened if we can. This should be a full\n   * sentence or paragraph that explains the error in more detail, for example\n   * to explain that a file failed to upload because it was too large and that\n   * the maximum size is 10MB.\n   */\n  why?: string;\n\n  /**\n   * If applicable, tell the user what the consequences of the error are, for\n   * example to tell them that their file was not uploaded and that they will\n   * need to try again.\n   */\n  consequences?: string;\n\n  /**\n   * If we can, tell the user what they can do to fix the error now. This should\n   * be a full sentence or paragraph that explains what the user can do to fix\n   * the error, for example to tell them to try uploading a smaller file or\n   * upgrade to a paid plan.\n   */\n  toFixNow?: string | string[];\n\n  /**\n   * If applicable, tell the user what to do if the error persists, they want\n   * more information, or the fix we've given them doesn't work.\n   *\n   * This should be a full sentence or paragraph, and will likely refer users\n   * to contact us for support, join our Discord, or read documentation.\n   */\n  otherwise?: string;\n\n  /**\n   * Add a stack trace to the message so that the user knows what line of code\n   * the error is in relation to.\n   */\n  stack?: true;\n\n  /**\n   * If applicable, provide a code that the user can use to reference the error\n   * when contacting support.\n   */\n  code?: ErrCode;\n}\n\nexport const prettyErrorSplitter =\n  \"=================================================\";\n\n/**\n * Given an unknown `err`, mutate it to minify any pretty errors that it\n * contains.\n */\nexport const minifyPrettyError = <T>(err: T): T => {\n  try {\n    if (!isError(err)) {\n      return err;\n    }\n\n    const isPrettyError = err.message.includes(prettyErrorSplitter);\n    if (!isPrettyError) {\n      return err;\n    }\n\n    const sanitizedMessage = stripAnsi(err.message);\n\n    const message =\n      sanitizedMessage.split(\"  \")[1]?.split(\"\\n\")[0]?.trim() || err.message;\n    const code =\n      sanitizedMessage.split(\"\\n\\nCode: \")[1]?.split(\"\\n\\n\")[0]?.trim() ||\n      undefined;\n\n    err.message = [code, message].filter(Boolean).join(\" - \");\n\n    if (err.stack) {\n      const sanitizedStack = stripAnsi(err.stack);\n      const stackRest = sanitizedStack\n        .split(`${prettyErrorSplitter}\\n`)\n        .slice(2)\n        .join(\"\\n\");\n\n      err.stack = `${err.name}: ${err.message}\\n${stackRest}`;\n    }\n\n    return err;\n  } catch (_noopErr) {\n    return err;\n  }\n};\n\n/**\n * Given an `err`, return a boolean representing whether it is in the shape of\n * an `Error` or not.\n */\nconst isError = (err: unknown): err is Error => {\n  try {\n    if (err instanceof Error) {\n      return true;\n    }\n\n    if (typeof err !== \"object\" || err === null) {\n      return false;\n    }\n\n    const hasName = Object.hasOwn(err, \"name\");\n    const hasMessage = Object.hasOwn(err, \"message\");\n\n    return hasName && hasMessage;\n  } catch (_noopErr) {\n    return false;\n  }\n};\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\n/**\n * Given a {@link PrettyError}, return a nicely-formatted string ready to log\n * or throw.\n *\n * Useful for ensuring that errors are logged in a consistent, helpful format\n * across the SDK by prompting for key pieces of information.\n */\nexport const prettyError = ({\n  type = \"error\",\n  whatHappened,\n  otherwise,\n  reassurance,\n  toFixNow,\n  why,\n  consequences,\n  stack,\n  code,\n}: PrettyError): string => {\n  const { icon, colorFn } = (\n    {\n      error: { icon: \"❌\", colorFn: chalk.red },\n      warn: { icon: \"⚠️\", colorFn: chalk.yellow },\n    } satisfies Record<\n      NonNullable<PrettyError[\"type\"]>,\n      { icon: string; colorFn: (s: string) => string }\n    >\n  )[type];\n\n  let header = `${icon}  ${chalk.bold.underline(whatHappened.trim())}`;\n  if (stack) {\n    header +=\n      \"\\n\" +\n      [...(new Error().stack?.split(\"\\n\").slice(1).filter(Boolean) || [])].join(\n        \"\\n\",\n      );\n  }\n\n  let toFixNowStr =\n    (Array.isArray(toFixNow)\n      ? toFixNow\n          .map((s) => s.trim())\n          .filter(Boolean)\n          .map((s, i) => `\\t${i + 1}. ${s}`)\n          .join(\"\\n\")\n      : toFixNow?.trim()) ?? \"\";\n\n  if (Array.isArray(toFixNow) && toFixNowStr) {\n    toFixNowStr = `To fix this, you can take one of the following courses of action:\\n\\n${toFixNowStr}`;\n  }\n\n  let body = [reassurance?.trim(), why?.trim(), consequences?.trim()]\n    .filter(Boolean)\n    .join(\" \");\n  body += body ? `\\n\\n${toFixNowStr}` : toFixNowStr;\n\n  const trailer = [otherwise?.trim()].filter(Boolean).join(\" \");\n\n  const message = [\n    prettyErrorSplitter,\n    header,\n    body,\n    trailer,\n    code ? `Code: ${code}` : \"\",\n    prettyErrorSplitter,\n  ]\n    .filter(Boolean)\n    .join(\"\\n\\n\");\n\n  return colorFn(message);\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n  `Use \\`inngest.${\"setEventKey\" satisfies keyof Inngest.Any}()\\` at runtime`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: <explanation>\n      throw err;\n    }\n  };\n};\n\n/**\n * Legacy v0 execution error for functions that don't support mixing steps and\n * regular async actions.\n */\nexport const functionStoppedRunningErr = (code: ErrCode) => {\n  return prettyError({\n    whatHappened: \"Your function was stopped from running\",\n    why: \"We detected a mix of asynchronous logic, some using step tooling and some not.\",\n    consequences:\n      \"This can cause unexpected behaviour when a function is paused and resumed and is therefore strongly discouraged; we stopped your function to ensure nothing unexpected happened!\",\n    stack: true,\n    toFixNow:\n      \"Ensure that your function is either entirely step-based or entirely non-step-based, by either wrapping all asynchronous logic in `step.run()` calls or by removing all `step.*()` calls.\",\n    otherwise:\n      \"For more information on why step functions work in this manner, see https://www.inngest.com/docs/functions/multi-step#gotchas\",\n    code,\n  });\n};\n"],"mappings":"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"}

package/helpers/strings.js

@@ -1,4 +1,4 @@
-import stringify from "json-stringify-safe";
+import safeStringify from "json-stringify-safe";
 import hashjs from "hash.js";
 import ms from "ms";
 
@@ -8,8 +8,8 @@ const { sha256 } = hashjs;
 * Safely `JSON.stringify()` an `input`, handling circular refernences and
 * removing `BigInt` values.
 */
-const stringify$1 = (input) => {
-	return stringify(input, (_key, value) => {
+const stringify = (input) => {
+	return safeStringify(input, (_key, value) => {
 		if (typeof value !== "bigint") return value;
 	});
 };
@@ -75,5 +75,5 @@ const hashSigningKey = (signingKey) => {
 };
 
 //#endregion
-export { hashEventKey, hashSigningKey, slugify, stringify$1 as stringify, stringifyUnknown, timeStr };
+export { hashEventKey, hashSigningKey, slugify, stringify, stringifyUnknown, timeStr };
 //# sourceMappingURL=strings.js.map

package/helpers/strings.js.map

@@ -1 +1 @@
-{"version":3,"file":"strings.js","names":["stringify","safeStringify","milliseconds: number","timeStr"],"sources":["../../src/helpers/strings.ts"],"sourcesContent":["import hashjs from \"hash.js\";\nimport { default as safeStringify } from \"json-stringify-safe\";\nimport ms from \"ms\";\nimport type { TimeStr } from \"../types.ts\";\n\nconst { sha256 } = hashjs;\n\n/**\n * Safely `JSON.stringify()` an `input`, handling circular refernences and\n * removing `BigInt` values.\n */\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport const stringify = (input: any): string => {\n  return safeStringify(input, (_key, value) => {\n    if (typeof value !== \"bigint\") {\n      return value;\n    }\n  });\n};\n\n/**\n * Returns a slugified string used to generate consistent IDs.\n *\n * This can be used to generate a consistent ID for a function when migrating\n * from v2 to v3 of the SDK.\n *\n * @public\n */\nexport const slugify = (str: string): string => {\n  const join = \"-\";\n  return str\n    .toLowerCase()\n    .replace(/[^a-z0-9-]+/g, join)\n    .replace(/-+/g, join)\n    .split(join)\n    .filter(Boolean)\n    .join(join);\n};\n\nconst millisecond = 1;\nconst second = millisecond * 1000;\nconst minute = second * 60;\nconst hour = minute * 60;\nconst day = hour * 24;\nconst week = day * 7;\n\n/**\n * A collection of periods in milliseconds and their suffixes used when creating\n * time strings.\n */\nconst periods = [\n  [\"w\", week],\n  [\"d\", day],\n  [\"h\", hour],\n  [\"m\", minute],\n  [\"s\", second],\n] as const;\n\n/**\n * Convert a given `Date`, `number`, or `ms`-compatible `string` to a\n * Inngest sleep-compatible time string (e.g. `\"1d\"` or `\"2h3010s\"`).\n *\n * Can optionally provide a `now` date to use as the base for the calculation,\n * otherwise a new date will be created on invocation.\n */\nexport const timeStr = (\n  /**\n   * The future date to use to convert to a time string.\n   */\n  input: string | number | Date,\n): string => {\n  if (input instanceof Date) {\n    return input.toISOString();\n  }\n\n  const milliseconds: number =\n    typeof input === \"string\" ? ms(input as `${number}`) : input;\n\n  const [, timeStr] = periods.reduce<[number, string]>(\n    ([num, str], [suffix, period]) => {\n      const numPeriods = Math.floor(num / period);\n\n      if (numPeriods > 0) {\n        return [num % period, `${str}${numPeriods}${suffix}`];\n      }\n\n      return [num, str];\n    },\n    [milliseconds, \"\"],\n  );\n\n  return timeStr as TimeStr;\n};\n\n/**\n * Given an unknown input, stringify it if it's a boolean, a number, or a\n * string, else return `undefined`.\n */\nexport const stringifyUnknown = (input: unknown): string | undefined => {\n  if (\n    typeof input === \"boolean\" ||\n    typeof input === \"number\" ||\n    typeof input === \"string\"\n  ) {\n    return input.toString();\n  }\n\n  return;\n};\n\nexport const hashEventKey = (eventKey: string): string => {\n  return sha256().update(eventKey).digest(\"hex\");\n};\n\nexport const hashSigningKey = (signingKey: string | undefined): string => {\n  if (!signingKey) {\n    return \"\";\n  }\n\n  const prefix = signingKey.match(/^signkey-[\\w]+-/)?.shift() || \"\";\n  const key = signingKey.replace(/^signkey-[\\w]+-/, \"\");\n\n  // Decode the key from its hex representation into a bytestream\n  return `${prefix}${sha256().update(key, \"hex\").digest(\"hex\")}`;\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,WAAW;;;;;AAOnB,MAAaA,eAAa,UAAuB;AAC/C,QAAOC,UAAc,QAAQ,MAAM,UAAU;AAC3C,MAAI,OAAO,UAAU,SACnB,QAAO;GAET;;;;;;;;;;AAWJ,MAAa,WAAW,QAAwB;CAC9C,MAAM,OAAO;AACb,QAAO,IACJ,aAAa,CACb,QAAQ,gBAAgB,KAAK,CAC7B,QAAQ,OAAO,KAAK,CACpB,MAAM,KAAK,CACX,OAAO,QAAQ,CACf,KAAK,KAAK;;AAIf,MAAM,SADc,IACS;AAC7B,MAAM,SAAS,SAAS;AACxB,MAAM,OAAO,SAAS;AACtB,MAAM,MAAM,OAAO;;;;;AAOnB,MAAM,UAAU;CACd,CAAC,KAPU,MAAM,EAON;CACX,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,OAAO;CACd;;;;;;;;AASD,MAAa,WAIX,UACW;AACX,KAAI,iBAAiB,KACnB,QAAO,MAAM,aAAa;CAG5B,MAAMC,eACJ,OAAO,UAAU,WAAW,GAAG,MAAqB,GAAG;CAEzD,MAAM,GAAGC,aAAW,QAAQ,QACzB,CAAC,KAAK,MAAM,CAAC,QAAQ,YAAY;EAChC,MAAM,aAAa,KAAK,MAAM,MAAM,OAAO;AAE3C,MAAI,aAAa,EACf,QAAO,CAAC,MAAM,QAAQ,GAAG,MAAM,aAAa,SAAS;AAGvD,SAAO,CAAC,KAAK,IAAI;IAEnB,CAAC,cAAc,GAAG,CACnB;AAED,QAAOA;;;;;;AAOT,MAAa,oBAAoB,UAAuC;AACtE,KACE,OAAO,UAAU,aACjB,OAAO,UAAU,YACjB,OAAO,UAAU,SAEjB,QAAO,MAAM,UAAU;;AAM3B,MAAa,gBAAgB,aAA6B;AACxD,QAAO,QAAQ,CAAC,OAAO,SAAS,CAAC,OAAO,MAAM;;AAGhD,MAAa,kBAAkB,eAA2C;AACxE,KAAI,CAAC,WACH,QAAO;CAGT,MAAM,SAAS,WAAW,MAAM,kBAAkB,EAAE,OAAO,IAAI;CAC/D,MAAM,MAAM,WAAW,QAAQ,mBAAmB,GAAG;AAGrD,QAAO,GAAG,SAAS,QAAQ,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,MAAM"}
+{"version":3,"file":"strings.js","names":["milliseconds: number","timeStr"],"sources":["../../src/helpers/strings.ts"],"sourcesContent":["import hashjs from \"hash.js\";\nimport { default as safeStringify } from \"json-stringify-safe\";\nimport ms from \"ms\";\nimport type { TimeStr } from \"../types.ts\";\n\nconst { sha256 } = hashjs;\n\n/**\n * Safely `JSON.stringify()` an `input`, handling circular refernences and\n * removing `BigInt` values.\n */\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport const stringify = (input: any): string => {\n  return safeStringify(input, (_key, value) => {\n    if (typeof value !== \"bigint\") {\n      return value;\n    }\n  });\n};\n\n/**\n * Returns a slugified string used to generate consistent IDs.\n *\n * This can be used to generate a consistent ID for a function when migrating\n * from v2 to v3 of the SDK.\n *\n * @public\n */\nexport const slugify = (str: string): string => {\n  const join = \"-\";\n  return str\n    .toLowerCase()\n    .replace(/[^a-z0-9-]+/g, join)\n    .replace(/-+/g, join)\n    .split(join)\n    .filter(Boolean)\n    .join(join);\n};\n\nconst millisecond = 1;\nconst second = millisecond * 1000;\nconst minute = second * 60;\nconst hour = minute * 60;\nconst day = hour * 24;\nconst week = day * 7;\n\n/**\n * A collection of periods in milliseconds and their suffixes used when creating\n * time strings.\n */\nconst periods = [\n  [\"w\", week],\n  [\"d\", day],\n  [\"h\", hour],\n  [\"m\", minute],\n  [\"s\", second],\n] as const;\n\n/**\n * Convert a given `Date`, `number`, or `ms`-compatible `string` to a\n * Inngest sleep-compatible time string (e.g. `\"1d\"` or `\"2h3010s\"`).\n *\n * Can optionally provide a `now` date to use as the base for the calculation,\n * otherwise a new date will be created on invocation.\n */\nexport const timeStr = (\n  /**\n   * The future date to use to convert to a time string.\n   */\n  input: string | number | Date,\n): string => {\n  if (input instanceof Date) {\n    return input.toISOString();\n  }\n\n  const milliseconds: number =\n    typeof input === \"string\" ? ms(input as `${number}`) : input;\n\n  const [, timeStr] = periods.reduce<[number, string]>(\n    ([num, str], [suffix, period]) => {\n      const numPeriods = Math.floor(num / period);\n\n      if (numPeriods > 0) {\n        return [num % period, `${str}${numPeriods}${suffix}`];\n      }\n\n      return [num, str];\n    },\n    [milliseconds, \"\"],\n  );\n\n  return timeStr as TimeStr;\n};\n\n/**\n * Given an unknown input, stringify it if it's a boolean, a number, or a\n * string, else return `undefined`.\n */\nexport const stringifyUnknown = (input: unknown): string | undefined => {\n  if (\n    typeof input === \"boolean\" ||\n    typeof input === \"number\" ||\n    typeof input === \"string\"\n  ) {\n    return input.toString();\n  }\n\n  return;\n};\n\nexport const hashEventKey = (eventKey: string): string => {\n  return sha256().update(eventKey).digest(\"hex\");\n};\n\nexport const hashSigningKey = (signingKey: string | undefined): string => {\n  if (!signingKey) {\n    return \"\";\n  }\n\n  const prefix = signingKey.match(/^signkey-[\\w]+-/)?.shift() || \"\";\n  const key = signingKey.replace(/^signkey-[\\w]+-/, \"\");\n\n  // Decode the key from its hex representation into a bytestream\n  return `${prefix}${sha256().update(key, \"hex\").digest(\"hex\")}`;\n};\n"],"mappings":";;;;;AAKA,MAAM,EAAE,WAAW;;;;;AAOnB,MAAa,aAAa,UAAuB;AAC/C,QAAO,cAAc,QAAQ,MAAM,UAAU;AAC3C,MAAI,OAAO,UAAU,SACnB,QAAO;GAET;;;;;;;;;;AAWJ,MAAa,WAAW,QAAwB;CAC9C,MAAM,OAAO;AACb,QAAO,IACJ,aAAa,CACb,QAAQ,gBAAgB,KAAK,CAC7B,QAAQ,OAAO,KAAK,CACpB,MAAM,KAAK,CACX,OAAO,QAAQ,CACf,KAAK,KAAK;;AAIf,MAAM,SADc,IACS;AAC7B,MAAM,SAAS,SAAS;AACxB,MAAM,OAAO,SAAS;AACtB,MAAM,MAAM,OAAO;;;;;AAOnB,MAAM,UAAU;CACd,CAAC,KAPU,MAAM,EAON;CACX,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,OAAO;CACb,CAAC,KAAK,OAAO;CACd;;;;;;;;AASD,MAAa,WAIX,UACW;AACX,KAAI,iBAAiB,KACnB,QAAO,MAAM,aAAa;CAG5B,MAAMA,eACJ,OAAO,UAAU,WAAW,GAAG,MAAqB,GAAG;CAEzD,MAAM,GAAGC,aAAW,QAAQ,QACzB,CAAC,KAAK,MAAM,CAAC,QAAQ,YAAY;EAChC,MAAM,aAAa,KAAK,MAAM,MAAM,OAAO;AAE3C,MAAI,aAAa,EACf,QAAO,CAAC,MAAM,QAAQ,GAAG,MAAM,aAAa,SAAS;AAGvD,SAAO,CAAC,KAAK,IAAI;IAEnB,CAAC,cAAc,GAAG,CACnB;AAED,QAAOA;;;;;;AAOT,MAAa,oBAAoB,UAAuC;AACtE,KACE,OAAO,UAAU,aACjB,OAAO,UAAU,YACjB,OAAO,UAAU,SAEjB,QAAO,MAAM,UAAU;;AAM3B,MAAa,gBAAgB,aAA6B;AACxD,QAAO,QAAQ,CAAC,OAAO,SAAS,CAAC,OAAO,MAAM;;AAGhD,MAAa,kBAAkB,eAA2C;AACxE,KAAI,CAAC,WACH,QAAO;CAGT,MAAM,SAAS,WAAW,MAAM,kBAAkB,EAAE,OAAO,IAAI;CAC/D,MAAM,MAAM,WAAW,QAAQ,mBAAmB,GAAG;AAGrD,QAAO,GAAG,SAAS,QAAQ,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,MAAM"}

package/nitro.cjs

@@ -18,8 +18,42 @@ 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"],"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"}
+{"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"}

package/nitro.d.cts

@@ -1,6 +1,7 @@
 import { SupportedFrameworkName } from "./types.cjs";
-import { ServeHandlerOptions } from "./components/InngestCommHandler.cjs";
+import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.cjs";
 import { serve as serve$1 } from "./h3.cjs";
+import * as h30 from "h3";
 
 //#region src/nitro.d.ts
 
@@ -16,6 +17,34 @@ 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 { frameworkName, serve };
+export { createExperimentalEndpointWrapper, 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":";;;;;;;;;;cAkBa,eAAe;;;;;;;cASf,iBACF,wBACR,kBAAkB"}
+{"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"}

package/nitro.d.ts

@@ -1,6 +1,7 @@
 import { SupportedFrameworkName } from "./types.js";
-import { ServeHandlerOptions } from "./components/InngestCommHandler.js";
+import { ServeHandlerOptions, SyncHandlerOptions } from "./components/InngestCommHandler.js";
 import { serve as serve$1 } from "./h3.js";
+import * as h30 from "h3";
 
 //#region src/nitro.d.ts
 
@@ -16,6 +17,34 @@ 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 { frameworkName, serve };
+export { createExperimentalEndpointWrapper, 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":";;;;;;;;;;cAkBa,eAAe;;;;;;;cASf,iBACF,wBACR,kBAAkB"}
+{"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"}

package/nitro.js

@@ -1,4 +1,4 @@
-import { serve as serve$1 } from "./h3.js";
+import { createExperimentalEndpointWrapper as createExperimentalEndpointWrapper$1, serve as serve$1 } from "./h3.js";
 
 //#region src/nitro.ts
 /**
@@ -18,7 +18,40 @@ 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 { frameworkName, serve };
+export { createExperimentalEndpointWrapper, frameworkName, serve };
 //# sourceMappingURL=nitro.js.map

package/nitro.js.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inngest",
-  "version": "3.48.1",
+  "version": "3.48.2-pr-1209.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

@@ -1235,12 +1235,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`;
-    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;
+    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;
   }, {
     period: string;
-    timeout?: string | undefined;
     key?: string | undefined;
+    timeout?: 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>>;
@@ -1341,8 +1341,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`;
-    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;
+    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;
   } | 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;
@@ -1401,8 +1401,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: string;
-    timeout?: string | undefined;
     key?: string | undefined;
+    timeout?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: string | undefined;

package/types.d.ts

@@ -1235,12 +1235,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`;
-    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;
+    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;
   }, {
     period: string;
-    timeout?: string | undefined;
     key?: string | undefined;
+    timeout?: 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>>;
@@ -1341,8 +1341,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`;
-    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;
+    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;
   } | 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;
@@ -1401,8 +1401,8 @@ declare const functionConfigSchema: z.ZodObject<{
   } | undefined;
   debounce?: {
     period: string;
-    timeout?: string | undefined;
     key?: string | undefined;
+    timeout?: string | undefined;
   } | undefined;
   timeouts?: {
     finish?: string | undefined;

package/version.cjs

@@ -1,6 +1,6 @@
 
 //#region src/version.ts
-const version = "3.48.1";
+const version = "3.48.2-pr-1209.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.1\";\n"],"mappings":";;AACA,MAAa,UAAU"}
+{"version":3,"file":"version.cjs","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.48.2-pr-1209.1\";\n"],"mappings":";;AACA,MAAa,UAAU"}

package/version.d.cts

@@ -1,5 +1,5 @@
 //#region src/version.d.ts
-declare const version = "3.48.1";
+declare const version = "3.48.2-pr-1209.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.1";
+declare const version = "3.48.2-pr-1209.1";
 //#endregion
 export { version };
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 //#region src/version.ts
-const version = "3.48.1";
+const version = "3.48.2-pr-1209.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.1\";\n"],"mappings":";AACA,MAAa,UAAU"}
+{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Generated by genversion.\nexport const version = \"3.48.2-pr-1209.1\";\n"],"mappings":";AACA,MAAa,UAAU"}