inngest 4.0.0-beta.3 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # inngest
 
+## 4.0.0
+
+### Major Changes
+
+- [#1346](https://github.com/inngest/inngest-js/pull/1346) [`e8024132`](https://github.com/inngest/inngest-js/commit/e80241321f1735dfe512dacacbfc5791c9f5da53) Thanks [@amh4r](https://github.com/amh4r)! - See list of changes in the migration guide: https://www.inngest.com/docs/reference/typescript/v4/migrations/v3-to-v4
+
+## 3.52.7
+
+### Patch Changes
+
+- [#1359](https://github.com/inngest/inngest-js/pull/1359) [`b4d9833f`](https://github.com/inngest/inngest-js/commit/b4d9833fe632f542aad10c6faf5da3fd6a6fc9b7) Thanks [@Linell](https://github.com/Linell)! - fix: use deterministic IDs for correct checkpointed parenting
+
+- [#1370](https://github.com/inngest/inngest-js/pull/1370) [`037336dc`](https://github.com/inngest/inngest-js/commit/037336dce8731aa9fcf5d56ff3e2d8a48e5aee6f) Thanks [@amh4r](https://github.com/amh4r)! - Fix mishandling drain message (Connect only)
+
+## 3.52.6
+
+### Patch Changes
+
+- [#1350](https://github.com/inngest/inngest-js/pull/1350) [`470fdb98`](https://github.com/inngest/inngest-js/commit/470fdb9845514b6597e0bd7c6db469d3808f6dcf) Thanks [@amh4r](https://github.com/amh4r)! - Fix false NESTING_STEPS error
+
+- [#1356](https://github.com/inngest/inngest-js/pull/1356) [`2e961c21`](https://github.com/inngest/inngest-js/commit/2e961c2169a451d60c3a14e8b9cc19e19ad0dec6) Thanks [@amh4r](https://github.com/amh4r)! - Fix checkpointing maxRuntime causing function run hang
+
+## 3.52.5
+
+### Patch Changes
+
+- [#1340](https://github.com/inngest/inngest-js/pull/1340) [`335703d7`](https://github.com/inngest/inngest-js/commit/335703d7372d092a865def4b2cfb4730e50d5fa9) Thanks [@Linell](https://github.com/Linell)! - fix: fallback to async flow on checkpoint error
+
+## 3.52.4
+
+### Patch Changes
+
+- [#1338](https://github.com/inngest/inngest-js/pull/1338) [`4f45adb7`](https://github.com/inngest/inngest-js/commit/4f45adb71fc7dfbc1ed7f941ddc4dd5e42f3523b) Thanks [@jakobevangelista](https://github.com/jakobevangelista)! - Fix signing key propagation from serve() options to InngestApi for outgoing API calls
+
 ## 3.52.3
 
 ### Patch Changes

package/components/ExperimentStrategies.cjs

@@ -0,0 +1,107 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_als = require('./execution/als.cjs');
+let hash_js = require("hash.js");
+hash_js = require_rolldown_runtime.__toESM(hash_js);
+
+//#region src/components/ExperimentStrategies.ts
+const { sha256 } = hash_js.default;
+/**
+* Hash a string to a float in [0, 1) using SHA-256.
+*/
+const hashToFloat = (str) => {
+	const hex = sha256().update(str).digest("hex").slice(0, 8);
+	return Number.parseInt(hex, 16) / 4294967296;
+};
+/**
+* Given a float in [0, 1) and a weights map, select the variant whose bucket
+* the float falls into. Entries are sorted alphabetically for determinism.
+*/
+const selectByWeight = (hash01, weights) => {
+	const entries = Object.entries(weights).sort(([a], [b]) => a.localeCompare(b));
+	const total = entries.reduce((sum, [, w]) => sum + w, 0);
+	let cursor = 0;
+	for (const [name, weight] of entries) {
+		cursor += weight / total;
+		if (hash01 < cursor) return name;
+	}
+	return entries[entries.length - 1][0];
+};
+/**
+* Build equal weights from variant names: `{ a: 1, b: 1, ... }`.
+*/
+const equalWeights = (variantNames) => {
+	return Object.fromEntries(variantNames.map((name) => [name, 1]));
+};
+/**
+* Throw if all weights are zero.
+*/
+const validateWeights = (weights) => {
+	for (const [name, w] of Object.entries(weights)) {
+		if (!Number.isFinite(w)) throw new Error(`experiment.weighted(): weight for "${name}" is not a finite number (${w}); weights must be finite numbers >= 0`);
+		if (w < 0) throw new Error(`experiment.weighted(): weight for "${name}" is negative (${w}); weights must be >= 0`);
+	}
+	if (Object.values(weights).reduce((sum, w) => sum + w, 0) <= 0) throw new Error("experiment.weighted(): all weights are zero; at least one weight must be positive");
+};
+/**
+* Attach `__experimentConfig` to a select function, producing an
+* `ExperimentSelectFn`.
+*/
+const createSelectFn = (fn, config) => {
+	return Object.assign(fn, { __experimentConfig: config });
+};
+/**
+* Factory functions for creating experiment selection strategies.
+*
+* Each factory returns an `ExperimentSelectFn` — a callable function with an
+* `__experimentConfig` property carrying strategy metadata.
+*
+* @example
+* ```ts
+* import { experiment, group, step } from "inngest";
+*
+* const result = await group.experiment("checkout-flow", {
+*   variants: {
+*     control: () => step.run("old", () => oldCheckout()),
+*     new_flow: () => step.run("new", () => newCheckout()),
+*   },
+*   select: experiment.weighted({ control: 80, new_flow: 20 }),
+* });
+* ```
+*
+* @public
+*/
+const experiment = {
+	fixed(variantName) {
+		return createSelectFn(() => variantName, { strategy: "fixed" });
+	},
+	weighted(weights) {
+		validateWeights(weights);
+		const frozen = { ...weights };
+		return createSelectFn(() => {
+			return selectByWeight(hashToFloat(require_als.getAsyncCtxSync()?.execution?.ctx.runId ?? crypto.randomUUID()), frozen);
+		}, {
+			strategy: "weighted",
+			weights: frozen
+		});
+	},
+	bucket(value, options) {
+		if (options?.weights) validateWeights(options.weights);
+		const str = value == null ? "" : String(value);
+		return createSelectFn((variantNames) => {
+			const weights = options?.weights ?? (variantNames ? equalWeights(variantNames) : void 0);
+			if (!weights) throw new Error("experiment.bucket() requires either explicit weights or variant names from group.experiment()");
+			return selectByWeight(hashToFloat(str), weights);
+		}, {
+			strategy: "bucket",
+			weights: options?.weights,
+			...value == null && { nullishBucket: true }
+		});
+	},
+	custom(fn) {
+		return createSelectFn(fn, { strategy: "custom" });
+	}
+};
+
+//#endregion
+exports.experiment = experiment;
+//# sourceMappingURL=ExperimentStrategies.cjs.map

package/components/ExperimentStrategies.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExperimentStrategies.cjs","names":["hashjs","getAsyncCtxSync"],"sources":["../../src/components/ExperimentStrategies.ts"],"sourcesContent":["import hashjs from \"hash.js\";\nimport { getAsyncCtxSync } from \"./execution/als.ts\";\nimport type { ExperimentSelectFn } from \"./InngestGroupTools.ts\";\n\nconst { sha256 } = hashjs;\n\n/**\n * Hash a string to a float in [0, 1) using SHA-256.\n */\nconst hashToFloat = (str: string): number => {\n  const hex = sha256().update(str).digest(\"hex\").slice(0, 8);\n  return Number.parseInt(hex, 16) / 0x100000000;\n};\n\n/**\n * Given a float in [0, 1) and a weights map, select the variant whose bucket\n * the float falls into. Entries are sorted alphabetically for determinism.\n */\nconst selectByWeight = (\n  hash01: number,\n  weights: Record<string, number>,\n): string => {\n  const entries = Object.entries(weights).sort(([a], [b]) =>\n    a.localeCompare(b),\n  );\n  const total = entries.reduce((sum, [, w]) => sum + w, 0);\n\n  let cursor = 0;\n  for (const [name, weight] of entries) {\n    cursor += weight / total;\n    if (hash01 < cursor) {\n      return name;\n    }\n  }\n\n  // Fallback to last entry (floating-point edge case)\n  return entries[entries.length - 1]![0]!;\n};\n\n/**\n * Build equal weights from variant names: `{ a: 1, b: 1, ... }`.\n */\nconst equalWeights = (variantNames: string[]): Record<string, number> => {\n  return Object.fromEntries(variantNames.map((name) => [name, 1]));\n};\n\n/**\n * Throw if all weights are zero.\n */\nconst validateWeights = (weights: Record<string, number>): void => {\n  for (const [name, w] of Object.entries(weights)) {\n    if (!Number.isFinite(w)) {\n      throw new Error(\n        `experiment.weighted(): weight for \"${name}\" is not a finite number (${w}); weights must be finite numbers >= 0`,\n      );\n    }\n    if (w < 0) {\n      throw new Error(\n        `experiment.weighted(): weight for \"${name}\" is negative (${w}); weights must be >= 0`,\n      );\n    }\n  }\n\n  const total = Object.values(weights).reduce((sum, w) => sum + w, 0);\n  if (total <= 0) {\n    throw new Error(\n      \"experiment.weighted(): all weights are zero; at least one weight must be positive\",\n    );\n  }\n};\n\n/**\n * Attach `__experimentConfig` to a select function, producing an\n * `ExperimentSelectFn`.\n */\nconst createSelectFn = (\n  fn: (variantNames?: string[]) => Promise<string> | string,\n  config: ExperimentSelectFn[\"__experimentConfig\"],\n): ExperimentSelectFn => {\n  return Object.assign(fn, { __experimentConfig: config });\n};\n\n/**\n * Factory functions for creating experiment selection strategies.\n *\n * Each factory returns an `ExperimentSelectFn` — a callable function with an\n * `__experimentConfig` property carrying strategy metadata.\n *\n * @example\n * ```ts\n * import { experiment, group, step } from \"inngest\";\n *\n * const result = await group.experiment(\"checkout-flow\", {\n *   variants: {\n *     control: () => step.run(\"old\", () => oldCheckout()),\n *     new_flow: () => step.run(\"new\", () => newCheckout()),\n *   },\n *   select: experiment.weighted({ control: 80, new_flow: 20 }),\n * });\n * ```\n *\n * @public\n */\nexport const experiment = {\n  /**\n   * Always selects the specified variant.\n   *\n   * @example\n   * ```ts\n   * select: experiment.fixed(\"control\")\n   * ```\n   */\n  fixed(variantName: string): ExperimentSelectFn {\n    return createSelectFn(() => variantName, { strategy: \"fixed\" });\n  },\n\n  /**\n   * Weighted random selection, seeded with the current run ID for\n   * determinism — the same run always gets the same variant.\n   *\n   * @example\n   * ```ts\n   * select: experiment.weighted({ gpt4: 50, claude: 50 })\n   * ```\n   *\n   * @throws If all weights are zero (validated at creation time).\n   */\n  weighted(weights: Record<string, number>): ExperimentSelectFn {\n    validateWeights(weights);\n\n    // Snapshot so that later mutations to the caller's object can't silently\n    // change runtime behaviour after validation has passed.\n    const frozen = { ...weights };\n\n    return createSelectFn(\n      () => {\n        const runId =\n          getAsyncCtxSync()?.execution?.ctx.runId ?? crypto.randomUUID();\n        return selectByWeight(hashToFloat(runId), frozen);\n      },\n      { strategy: \"weighted\", weights: frozen },\n    );\n  },\n\n  /**\n   * Consistent hashing — the same value always maps to the same variant.\n   *\n   * When `value` is `null` or `undefined`, an empty string is hashed instead.\n   *\n   * @example\n   * ```ts\n   * select: experiment.bucket(userId)\n   * select: experiment.bucket(userId, { weights: { a: 70, b: 30 } })\n   * ```\n   */\n  bucket(\n    value: unknown,\n    options?: { weights?: Record<string, number> },\n  ): ExperimentSelectFn {\n    if (options?.weights) {\n      validateWeights(options.weights);\n    }\n\n    const str = value == null ? \"\" : String(value);\n\n    return createSelectFn(\n      (variantNames?: string[]) => {\n        const weights =\n          options?.weights ??\n          (variantNames ? equalWeights(variantNames) : undefined);\n\n        if (!weights) {\n          throw new Error(\n            \"experiment.bucket() requires either explicit weights or variant \" +\n              \"names from group.experiment()\",\n          );\n        }\n\n        return selectByWeight(hashToFloat(str), weights);\n      },\n      {\n        strategy: \"bucket\",\n        weights: options?.weights,\n        ...(value == null && { nullishBucket: true }),\n      },\n    );\n  },\n\n  /**\n   * User-provided selection function. The function is called inside the\n   * memoized step, so it only runs once per run.\n   *\n   * @example\n   * ```ts\n   * select: experiment.custom(async () => {\n   *   const flag = await getFeatureFlag(\"checkout-variant\");\n   *   return flag;\n   * })\n   * ```\n   */\n  custom(fn: () => Promise<string> | string): ExperimentSelectFn {\n    return createSelectFn(fn, { strategy: \"custom\" });\n  },\n};\n"],"mappings":";;;;;;AAIA,MAAM,EAAE,WAAWA;;;;AAKnB,MAAM,eAAe,QAAwB;CAC3C,MAAM,MAAM,QAAQ,CAAC,OAAO,IAAI,CAAC,OAAO,MAAM,CAAC,MAAM,GAAG,EAAE;AAC1D,QAAO,OAAO,SAAS,KAAK,GAAG,GAAG;;;;;;AAOpC,MAAM,kBACJ,QACA,YACW;CACX,MAAM,UAAU,OAAO,QAAQ,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAClD,EAAE,cAAc,EAAE,CACnB;CACD,MAAM,QAAQ,QAAQ,QAAQ,KAAK,GAAG,OAAO,MAAM,GAAG,EAAE;CAExD,IAAI,SAAS;AACb,MAAK,MAAM,CAAC,MAAM,WAAW,SAAS;AACpC,YAAU,SAAS;AACnB,MAAI,SAAS,OACX,QAAO;;AAKX,QAAO,QAAQ,QAAQ,SAAS,GAAI;;;;;AAMtC,MAAM,gBAAgB,iBAAmD;AACvE,QAAO,OAAO,YAAY,aAAa,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;;;;;AAMlE,MAAM,mBAAmB,YAA0C;AACjE,MAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAAQ,QAAQ,EAAE;AAC/C,MAAI,CAAC,OAAO,SAAS,EAAE,CACrB,OAAM,IAAI,MACR,sCAAsC,KAAK,4BAA4B,EAAE,wCAC1E;AAEH,MAAI,IAAI,EACN,OAAM,IAAI,MACR,sCAAsC,KAAK,iBAAiB,EAAE,yBAC/D;;AAKL,KADc,OAAO,OAAO,QAAQ,CAAC,QAAQ,KAAK,MAAM,MAAM,GAAG,EAAE,IACtD,EACX,OAAM,IAAI,MACR,oFACD;;;;;;AAQL,MAAM,kBACJ,IACA,WACuB;AACvB,QAAO,OAAO,OAAO,IAAI,EAAE,oBAAoB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwB1D,MAAa,aAAa;CASxB,MAAM,aAAyC;AAC7C,SAAO,qBAAqB,aAAa,EAAE,UAAU,SAAS,CAAC;;CAcjE,SAAS,SAAqD;AAC5D,kBAAgB,QAAQ;EAIxB,MAAM,SAAS,EAAE,GAAG,SAAS;AAE7B,SAAO,qBACC;AAGJ,UAAO,eAAe,YADpBC,6BAAiB,EAAE,WAAW,IAAI,SAAS,OAAO,YAAY,CACxB,EAAE,OAAO;KAEnD;GAAE,UAAU;GAAY,SAAS;GAAQ,CAC1C;;CAcH,OACE,OACA,SACoB;AACpB,MAAI,SAAS,QACX,iBAAgB,QAAQ,QAAQ;EAGlC,MAAM,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM;AAE9C,SAAO,gBACJ,iBAA4B;GAC3B,MAAM,UACJ,SAAS,YACR,eAAe,aAAa,aAAa,GAAG;AAE/C,OAAI,CAAC,QACH,OAAM,IAAI,MACR,gGAED;AAGH,UAAO,eAAe,YAAY,IAAI,EAAE,QAAQ;KAElD;GACE,UAAU;GACV,SAAS,SAAS;GAClB,GAAI,SAAS,QAAQ,EAAE,eAAe,MAAM;GAC7C,CACF;;CAeH,OAAO,IAAwD;AAC7D,SAAO,eAAe,IAAI,EAAE,UAAU,UAAU,CAAC;;CAEpD"}

package/components/ExperimentStrategies.d.cts

@@ -0,0 +1,78 @@
+import { ExperimentSelectFn } from "./InngestGroupTools.cjs";
+
+//#region src/components/ExperimentStrategies.d.ts
+
+/**
+ * Factory functions for creating experiment selection strategies.
+ *
+ * Each factory returns an `ExperimentSelectFn` — a callable function with an
+ * `__experimentConfig` property carrying strategy metadata.
+ *
+ * @example
+ * ```ts
+ * import { experiment, group, step } from "inngest";
+ *
+ * const result = await group.experiment("checkout-flow", {
+ *   variants: {
+ *     control: () => step.run("old", () => oldCheckout()),
+ *     new_flow: () => step.run("new", () => newCheckout()),
+ *   },
+ *   select: experiment.weighted({ control: 80, new_flow: 20 }),
+ * });
+ * ```
+ *
+ * @public
+ */
+declare const experiment: {
+  /**
+   * Always selects the specified variant.
+   *
+   * @example
+   * ```ts
+   * select: experiment.fixed("control")
+   * ```
+   */
+  fixed(variantName: string): ExperimentSelectFn;
+  /**
+   * Weighted random selection, seeded with the current run ID for
+   * determinism — the same run always gets the same variant.
+   *
+   * @example
+   * ```ts
+   * select: experiment.weighted({ gpt4: 50, claude: 50 })
+   * ```
+   *
+   * @throws If all weights are zero (validated at creation time).
+   */
+  weighted(weights: Record<string, number>): ExperimentSelectFn;
+  /**
+   * Consistent hashing — the same value always maps to the same variant.
+   *
+   * When `value` is `null` or `undefined`, an empty string is hashed instead.
+   *
+   * @example
+   * ```ts
+   * select: experiment.bucket(userId)
+   * select: experiment.bucket(userId, { weights: { a: 70, b: 30 } })
+   * ```
+   */
+  bucket(value: unknown, options?: {
+    weights?: Record<string, number>;
+  }): ExperimentSelectFn;
+  /**
+   * User-provided selection function. The function is called inside the
+   * memoized step, so it only runs once per run.
+   *
+   * @example
+   * ```ts
+   * select: experiment.custom(async () => {
+   *   const flag = await getFeatureFlag("checkout-variant");
+   *   return flag;
+   * })
+   * ```
+   */
+  custom(fn: () => Promise<string> | string): ExperimentSelectFn;
+};
+//#endregion
+export { experiment };
+//# sourceMappingURL=ExperimentStrategies.d.cts.map

package/components/ExperimentStrategies.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExperimentStrategies.d.cts","names":[],"sources":["../../src/components/ExperimentStrategies.ts"],"sourcesContent":[],"mappings":";;;;;;AAuGA;;;;;;;;;;;;;;;;;;;cAAa;;;;;;;;;8BASiB;;;;;;;;;;;;oBAeV,yBAAyB;;;;;;;;;;;;;cA8BnB;MACrB;;;;;;;;;;;;;mBA0Cc,2BAA2B"}

package/components/ExperimentStrategies.d.ts

@@ -0,0 +1,78 @@
+import { ExperimentSelectFn } from "./InngestGroupTools.js";
+
+//#region src/components/ExperimentStrategies.d.ts
+
+/**
+ * Factory functions for creating experiment selection strategies.
+ *
+ * Each factory returns an `ExperimentSelectFn` — a callable function with an
+ * `__experimentConfig` property carrying strategy metadata.
+ *
+ * @example
+ * ```ts
+ * import { experiment, group, step } from "inngest";
+ *
+ * const result = await group.experiment("checkout-flow", {
+ *   variants: {
+ *     control: () => step.run("old", () => oldCheckout()),
+ *     new_flow: () => step.run("new", () => newCheckout()),
+ *   },
+ *   select: experiment.weighted({ control: 80, new_flow: 20 }),
+ * });
+ * ```
+ *
+ * @public
+ */
+declare const experiment: {
+  /**
+   * Always selects the specified variant.
+   *
+   * @example
+   * ```ts
+   * select: experiment.fixed("control")
+   * ```
+   */
+  fixed(variantName: string): ExperimentSelectFn;
+  /**
+   * Weighted random selection, seeded with the current run ID for
+   * determinism — the same run always gets the same variant.
+   *
+   * @example
+   * ```ts
+   * select: experiment.weighted({ gpt4: 50, claude: 50 })
+   * ```
+   *
+   * @throws If all weights are zero (validated at creation time).
+   */
+  weighted(weights: Record<string, number>): ExperimentSelectFn;
+  /**
+   * Consistent hashing — the same value always maps to the same variant.
+   *
+   * When `value` is `null` or `undefined`, an empty string is hashed instead.
+   *
+   * @example
+   * ```ts
+   * select: experiment.bucket(userId)
+   * select: experiment.bucket(userId, { weights: { a: 70, b: 30 } })
+   * ```
+   */
+  bucket(value: unknown, options?: {
+    weights?: Record<string, number>;
+  }): ExperimentSelectFn;
+  /**
+   * User-provided selection function. The function is called inside the
+   * memoized step, so it only runs once per run.
+   *
+   * @example
+   * ```ts
+   * select: experiment.custom(async () => {
+   *   const flag = await getFeatureFlag("checkout-variant");
+   *   return flag;
+   * })
+   * ```
+   */
+  custom(fn: () => Promise<string> | string): ExperimentSelectFn;
+};
+//#endregion
+export { experiment };
+//# sourceMappingURL=ExperimentStrategies.d.ts.map

package/components/ExperimentStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExperimentStrategies.d.ts","names":[],"sources":["../../src/components/ExperimentStrategies.ts"],"sourcesContent":[],"mappings":";;;;;;AAuGA;;;;;;;;;;;;;;;;;;;cAAa;;;;;;;;;8BASiB;;;;;;;;;;;;oBAeV,yBAAyB;;;;;;;;;;;;;cA8BnB;MACrB;;;;;;;;;;;;;mBA0Cc,2BAA2B"}

package/components/ExperimentStrategies.js

@@ -0,0 +1,105 @@
+import { getAsyncCtxSync } from "./execution/als.js";
+import hashjs from "hash.js";
+
+//#region src/components/ExperimentStrategies.ts
+const { sha256 } = hashjs;
+/**
+* Hash a string to a float in [0, 1) using SHA-256.
+*/
+const hashToFloat = (str) => {
+	const hex = sha256().update(str).digest("hex").slice(0, 8);
+	return Number.parseInt(hex, 16) / 4294967296;
+};
+/**
+* Given a float in [0, 1) and a weights map, select the variant whose bucket
+* the float falls into. Entries are sorted alphabetically for determinism.
+*/
+const selectByWeight = (hash01, weights) => {
+	const entries = Object.entries(weights).sort(([a], [b]) => a.localeCompare(b));
+	const total = entries.reduce((sum, [, w]) => sum + w, 0);
+	let cursor = 0;
+	for (const [name, weight] of entries) {
+		cursor += weight / total;
+		if (hash01 < cursor) return name;
+	}
+	return entries[entries.length - 1][0];
+};
+/**
+* Build equal weights from variant names: `{ a: 1, b: 1, ... }`.
+*/
+const equalWeights = (variantNames) => {
+	return Object.fromEntries(variantNames.map((name) => [name, 1]));
+};
+/**
+* Throw if all weights are zero.
+*/
+const validateWeights = (weights) => {
+	for (const [name, w] of Object.entries(weights)) {
+		if (!Number.isFinite(w)) throw new Error(`experiment.weighted(): weight for "${name}" is not a finite number (${w}); weights must be finite numbers >= 0`);
+		if (w < 0) throw new Error(`experiment.weighted(): weight for "${name}" is negative (${w}); weights must be >= 0`);
+	}
+	if (Object.values(weights).reduce((sum, w) => sum + w, 0) <= 0) throw new Error("experiment.weighted(): all weights are zero; at least one weight must be positive");
+};
+/**
+* Attach `__experimentConfig` to a select function, producing an
+* `ExperimentSelectFn`.
+*/
+const createSelectFn = (fn, config) => {
+	return Object.assign(fn, { __experimentConfig: config });
+};
+/**
+* Factory functions for creating experiment selection strategies.
+*
+* Each factory returns an `ExperimentSelectFn` — a callable function with an
+* `__experimentConfig` property carrying strategy metadata.
+*
+* @example
+* ```ts
+* import { experiment, group, step } from "inngest";
+*
+* const result = await group.experiment("checkout-flow", {
+*   variants: {
+*     control: () => step.run("old", () => oldCheckout()),
+*     new_flow: () => step.run("new", () => newCheckout()),
+*   },
+*   select: experiment.weighted({ control: 80, new_flow: 20 }),
+* });
+* ```
+*
+* @public
+*/
+const experiment = {
+	fixed(variantName) {
+		return createSelectFn(() => variantName, { strategy: "fixed" });
+	},
+	weighted(weights) {
+		validateWeights(weights);
+		const frozen = { ...weights };
+		return createSelectFn(() => {
+			return selectByWeight(hashToFloat(getAsyncCtxSync()?.execution?.ctx.runId ?? crypto.randomUUID()), frozen);
+		}, {
+			strategy: "weighted",
+			weights: frozen
+		});
+	},
+	bucket(value, options) {
+		if (options?.weights) validateWeights(options.weights);
+		const str = value == null ? "" : String(value);
+		return createSelectFn((variantNames) => {
+			const weights = options?.weights ?? (variantNames ? equalWeights(variantNames) : void 0);
+			if (!weights) throw new Error("experiment.bucket() requires either explicit weights or variant names from group.experiment()");
+			return selectByWeight(hashToFloat(str), weights);
+		}, {
+			strategy: "bucket",
+			weights: options?.weights,
+			...value == null && { nullishBucket: true }
+		});
+	},
+	custom(fn) {
+		return createSelectFn(fn, { strategy: "custom" });
+	}
+};
+
+//#endregion
+export { experiment };
+//# sourceMappingURL=ExperimentStrategies.js.map

package/components/ExperimentStrategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExperimentStrategies.js","names":[],"sources":["../../src/components/ExperimentStrategies.ts"],"sourcesContent":["import hashjs from \"hash.js\";\nimport { getAsyncCtxSync } from \"./execution/als.ts\";\nimport type { ExperimentSelectFn } from \"./InngestGroupTools.ts\";\n\nconst { sha256 } = hashjs;\n\n/**\n * Hash a string to a float in [0, 1) using SHA-256.\n */\nconst hashToFloat = (str: string): number => {\n  const hex = sha256().update(str).digest(\"hex\").slice(0, 8);\n  return Number.parseInt(hex, 16) / 0x100000000;\n};\n\n/**\n * Given a float in [0, 1) and a weights map, select the variant whose bucket\n * the float falls into. Entries are sorted alphabetically for determinism.\n */\nconst selectByWeight = (\n  hash01: number,\n  weights: Record<string, number>,\n): string => {\n  const entries = Object.entries(weights).sort(([a], [b]) =>\n    a.localeCompare(b),\n  );\n  const total = entries.reduce((sum, [, w]) => sum + w, 0);\n\n  let cursor = 0;\n  for (const [name, weight] of entries) {\n    cursor += weight / total;\n    if (hash01 < cursor) {\n      return name;\n    }\n  }\n\n  // Fallback to last entry (floating-point edge case)\n  return entries[entries.length - 1]![0]!;\n};\n\n/**\n * Build equal weights from variant names: `{ a: 1, b: 1, ... }`.\n */\nconst equalWeights = (variantNames: string[]): Record<string, number> => {\n  return Object.fromEntries(variantNames.map((name) => [name, 1]));\n};\n\n/**\n * Throw if all weights are zero.\n */\nconst validateWeights = (weights: Record<string, number>): void => {\n  for (const [name, w] of Object.entries(weights)) {\n    if (!Number.isFinite(w)) {\n      throw new Error(\n        `experiment.weighted(): weight for \"${name}\" is not a finite number (${w}); weights must be finite numbers >= 0`,\n      );\n    }\n    if (w < 0) {\n      throw new Error(\n        `experiment.weighted(): weight for \"${name}\" is negative (${w}); weights must be >= 0`,\n      );\n    }\n  }\n\n  const total = Object.values(weights).reduce((sum, w) => sum + w, 0);\n  if (total <= 0) {\n    throw new Error(\n      \"experiment.weighted(): all weights are zero; at least one weight must be positive\",\n    );\n  }\n};\n\n/**\n * Attach `__experimentConfig` to a select function, producing an\n * `ExperimentSelectFn`.\n */\nconst createSelectFn = (\n  fn: (variantNames?: string[]) => Promise<string> | string,\n  config: ExperimentSelectFn[\"__experimentConfig\"],\n): ExperimentSelectFn => {\n  return Object.assign(fn, { __experimentConfig: config });\n};\n\n/**\n * Factory functions for creating experiment selection strategies.\n *\n * Each factory returns an `ExperimentSelectFn` — a callable function with an\n * `__experimentConfig` property carrying strategy metadata.\n *\n * @example\n * ```ts\n * import { experiment, group, step } from \"inngest\";\n *\n * const result = await group.experiment(\"checkout-flow\", {\n *   variants: {\n *     control: () => step.run(\"old\", () => oldCheckout()),\n *     new_flow: () => step.run(\"new\", () => newCheckout()),\n *   },\n *   select: experiment.weighted({ control: 80, new_flow: 20 }),\n * });\n * ```\n *\n * @public\n */\nexport const experiment = {\n  /**\n   * Always selects the specified variant.\n   *\n   * @example\n   * ```ts\n   * select: experiment.fixed(\"control\")\n   * ```\n   */\n  fixed(variantName: string): ExperimentSelectFn {\n    return createSelectFn(() => variantName, { strategy: \"fixed\" });\n  },\n\n  /**\n   * Weighted random selection, seeded with the current run ID for\n   * determinism — the same run always gets the same variant.\n   *\n   * @example\n   * ```ts\n   * select: experiment.weighted({ gpt4: 50, claude: 50 })\n   * ```\n   *\n   * @throws If all weights are zero (validated at creation time).\n   */\n  weighted(weights: Record<string, number>): ExperimentSelectFn {\n    validateWeights(weights);\n\n    // Snapshot so that later mutations to the caller's object can't silently\n    // change runtime behaviour after validation has passed.\n    const frozen = { ...weights };\n\n    return createSelectFn(\n      () => {\n        const runId =\n          getAsyncCtxSync()?.execution?.ctx.runId ?? crypto.randomUUID();\n        return selectByWeight(hashToFloat(runId), frozen);\n      },\n      { strategy: \"weighted\", weights: frozen },\n    );\n  },\n\n  /**\n   * Consistent hashing — the same value always maps to the same variant.\n   *\n   * When `value` is `null` or `undefined`, an empty string is hashed instead.\n   *\n   * @example\n   * ```ts\n   * select: experiment.bucket(userId)\n   * select: experiment.bucket(userId, { weights: { a: 70, b: 30 } })\n   * ```\n   */\n  bucket(\n    value: unknown,\n    options?: { weights?: Record<string, number> },\n  ): ExperimentSelectFn {\n    if (options?.weights) {\n      validateWeights(options.weights);\n    }\n\n    const str = value == null ? \"\" : String(value);\n\n    return createSelectFn(\n      (variantNames?: string[]) => {\n        const weights =\n          options?.weights ??\n          (variantNames ? equalWeights(variantNames) : undefined);\n\n        if (!weights) {\n          throw new Error(\n            \"experiment.bucket() requires either explicit weights or variant \" +\n              \"names from group.experiment()\",\n          );\n        }\n\n        return selectByWeight(hashToFloat(str), weights);\n      },\n      {\n        strategy: \"bucket\",\n        weights: options?.weights,\n        ...(value == null && { nullishBucket: true }),\n      },\n    );\n  },\n\n  /**\n   * User-provided selection function. The function is called inside the\n   * memoized step, so it only runs once per run.\n   *\n   * @example\n   * ```ts\n   * select: experiment.custom(async () => {\n   *   const flag = await getFeatureFlag(\"checkout-variant\");\n   *   return flag;\n   * })\n   * ```\n   */\n  custom(fn: () => Promise<string> | string): ExperimentSelectFn {\n    return createSelectFn(fn, { strategy: \"custom\" });\n  },\n};\n"],"mappings":";;;;AAIA,MAAM,EAAE,WAAW;;;;AAKnB,MAAM,eAAe,QAAwB;CAC3C,MAAM,MAAM,QAAQ,CAAC,OAAO,IAAI,CAAC,OAAO,MAAM,CAAC,MAAM,GAAG,EAAE;AAC1D,QAAO,OAAO,SAAS,KAAK,GAAG,GAAG;;;;;;AAOpC,MAAM,kBACJ,QACA,YACW;CACX,MAAM,UAAU,OAAO,QAAQ,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAClD,EAAE,cAAc,EAAE,CACnB;CACD,MAAM,QAAQ,QAAQ,QAAQ,KAAK,GAAG,OAAO,MAAM,GAAG,EAAE;CAExD,IAAI,SAAS;AACb,MAAK,MAAM,CAAC,MAAM,WAAW,SAAS;AACpC,YAAU,SAAS;AACnB,MAAI,SAAS,OACX,QAAO;;AAKX,QAAO,QAAQ,QAAQ,SAAS,GAAI;;;;;AAMtC,MAAM,gBAAgB,iBAAmD;AACvE,QAAO,OAAO,YAAY,aAAa,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;;;;;AAMlE,MAAM,mBAAmB,YAA0C;AACjE,MAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAAQ,QAAQ,EAAE;AAC/C,MAAI,CAAC,OAAO,SAAS,EAAE,CACrB,OAAM,IAAI,MACR,sCAAsC,KAAK,4BAA4B,EAAE,wCAC1E;AAEH,MAAI,IAAI,EACN,OAAM,IAAI,MACR,sCAAsC,KAAK,iBAAiB,EAAE,yBAC/D;;AAKL,KADc,OAAO,OAAO,QAAQ,CAAC,QAAQ,KAAK,MAAM,MAAM,GAAG,EAAE,IACtD,EACX,OAAM,IAAI,MACR,oFACD;;;;;;AAQL,MAAM,kBACJ,IACA,WACuB;AACvB,QAAO,OAAO,OAAO,IAAI,EAAE,oBAAoB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwB1D,MAAa,aAAa;CASxB,MAAM,aAAyC;AAC7C,SAAO,qBAAqB,aAAa,EAAE,UAAU,SAAS,CAAC;;CAcjE,SAAS,SAAqD;AAC5D,kBAAgB,QAAQ;EAIxB,MAAM,SAAS,EAAE,GAAG,SAAS;AAE7B,SAAO,qBACC;AAGJ,UAAO,eAAe,YADpB,iBAAiB,EAAE,WAAW,IAAI,SAAS,OAAO,YAAY,CACxB,EAAE,OAAO;KAEnD;GAAE,UAAU;GAAY,SAAS;GAAQ,CAC1C;;CAcH,OACE,OACA,SACoB;AACpB,MAAI,SAAS,QACX,iBAAgB,QAAQ,QAAQ;EAGlC,MAAM,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM;AAE9C,SAAO,gBACJ,iBAA4B;GAC3B,MAAM,UACJ,SAAS,YACR,eAAe,aAAa,aAAa,GAAG;AAE/C,OAAI,CAAC,QACH,OAAM,IAAI,MACR,gGAED;AAGH,UAAO,eAAe,YAAY,IAAI,EAAE,QAAQ;KAElD;GACE,UAAU;GACV,SAAS,SAAS;GAClB,GAAI,SAAS,QAAQ,EAAE,eAAe,MAAM;GAC7C,CACF;;CAeH,OAAO,IAAwD;AAC7D,SAAO,eAAe,IAAI,EAAE,UAAU,UAAU,CAAC;;CAEpD"}

package/components/Fetch.cjs

@@ -6,23 +6,23 @@ debug = require_rolldown_runtime.__toESM(debug);
 
 //#region src/components/Fetch.ts
 const globalFetch = globalThis.fetch;
-const debug$1 = (0, debug.default)("inngest:fetch");
+const devDebug = (0, debug.default)("inngest:fetch");
 const createFetchShim = () => {
 	let stepFetch;
 	const fetch$1 = async (input, init) => {
 		const ctx = await require_als.getAsyncCtx();
 		if (!ctx?.execution) {
 			if (!stepFetch.fallback) throw new Error("step.fetch() called outside of a function and had no fallback set");
-			debug$1("step.fetch() called outside of a function; falling back to global fetch");
+			devDebug("step.fetch() called outside of a function; falling back to global fetch");
 			return stepFetch.fallback(input, init);
 		}
 		if (ctx.execution.executingStep) {
 			if (!stepFetch.fallback) throw new Error(`step.fetch() called inside step "${ctx.execution.executingStep.id}" and had no fallback set`);
-			debug$1(`step.fetch() called inside step "${ctx.execution.executingStep.id}"; falling back to global fetch`);
+			devDebug(`step.fetch() called inside step "${ctx.execution.executingStep.id}"; falling back to global fetch`);
 			return stepFetch.fallback(input, init);
 		}
 		const targetUrl = new URL(input instanceof Request ? input.url : input.toString());
-		debug$1("step.fetch() shimming request to", targetUrl.hostname);
+		devDebug("step.fetch() shimming request to", targetUrl.hostname);
 		const jsonRes = await ctx.execution.ctx.step[require_InngestStepTools.gatewaySymbol](`step.fetch: ${targetUrl.hostname}`, input, init);
 		return new Response(jsonRes.body, {
 			headers: jsonRes.headers,

package/components/Fetch.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"Fetch.cjs","names":["debug","stepFetch: StepFetch","fetch: Fetch","getAsyncCtx","gatewaySymbol","optionsRef: StepFetch.Options","extras: StepFetch.Extras","fetch"],"sources":["../../src/components/Fetch.ts"],"sourcesContent":["import Debug from \"debug\";\nimport type { Simplify } from \"../helpers/types.ts\";\nimport { getAsyncCtx } from \"./execution/als.ts\";\nimport { gatewaySymbol, type InternalStepTools } from \"./InngestStepTools.ts\";\n\nconst globalFetch = globalThis.fetch;\ntype Fetch = typeof globalFetch;\n\nexport type StepFetch = Fetch &\n  Simplify<\n    {\n      config: (options: StepFetch.Options) => StepFetch;\n    } & Readonly<StepFetch.Options>\n  >;\n\nexport namespace StepFetch {\n  export interface Options {\n    fallback?: Fetch | undefined;\n  }\n\n  export interface Extras extends Options {\n    config: (options: Options) => StepFetch;\n  }\n}\n\nconst debug = Debug(\"inngest:fetch\");\n\nconst createFetchShim = (): StepFetch => {\n  // biome-ignore lint/style/useConst: need this to allow fns to be defined\n  let stepFetch: StepFetch;\n\n  const fetch: Fetch = async (input, init) => {\n    const ctx = await getAsyncCtx();\n    if (!ctx?.execution) {\n      // Not in a function run\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          \"step.fetch() called outside of a function and had no fallback set\",\n        );\n      }\n\n      debug(\n        \"step.fetch() called outside of a function; falling back to global fetch\",\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // In a function run\n    if (ctx.execution.executingStep) {\n      // Inside a step\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          `step.fetch() called inside step \"${ctx.execution.executingStep.id}\" and had no fallback set`,\n        );\n      }\n\n      debug(\n        `step.fetch() called inside step \"${ctx.execution.executingStep.id}\"; falling back to global fetch`,\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // TODO Do we need to make this better with deferred (global) step tooling?\n    // hmmmmm\n\n    const targetUrl = new URL(\n      input instanceof Request ? input.url : input.toString(),\n    );\n\n    debug(\"step.fetch() shimming request to\", targetUrl.hostname);\n\n    // Purposefully do not try/cacth this; if it throws then we treat that as a\n    // regular `fetch()` throw, which also would not return a `Response`.\n    const jsonRes = await (ctx.execution.ctx.step as InternalStepTools)[\n      gatewaySymbol\n    ](`step.fetch: ${targetUrl.hostname}`, input, init);\n\n    return new Response(jsonRes.body, {\n      headers: jsonRes.headers,\n      status: jsonRes.status_code,\n    });\n  };\n\n  const optionsRef: StepFetch.Options = {\n    fallback: globalFetch,\n  };\n\n  const extras: StepFetch.Extras = {\n    config: (options) => {\n      Object.assign(optionsRef, options);\n      Object.assign(stepFetch, optionsRef);\n\n      return stepFetch;\n    },\n    ...optionsRef,\n  };\n\n  stepFetch = Object.assign(fetch, extras);\n\n  return stepFetch;\n};\n\n/**\n * `fetch` is a Fetch API-compatible function that can be used to make any HTTP\n * code durable if it's called within an Inngest function.\n *\n * It will gracefully fall back to the global `fetch` if called outside of this\n * context, and a custom fallback can be set using the `config` method.\n *\n * @example Basic usage\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({ fetch });\n * ```\n *\n * @example Setting a custom fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: myCustomFetch }),\n * });\n * ```\n *\n * @example Do not allow fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: undefined }),\n * });\n * ```\n */\nexport const fetch = createFetchShim();\n"],"mappings":";;;;;;;AAKA,MAAM,cAAc,WAAW;AAoB/B,MAAMA,6BAAc,gBAAgB;AAEpC,MAAM,wBAAmC;CAEvC,IAAIC;CAEJ,MAAMC,UAAe,OAAO,OAAO,SAAS;EAC1C,MAAM,MAAM,MAAMC,yBAAa;AAC/B,MAAI,CAAC,KAAK,WAAW;AAEnB,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oEACD;AAGH,WACE,0EACD;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;AAIxC,MAAI,IAAI,UAAU,eAAe;AAE/B,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oCAAoC,IAAI,UAAU,cAAc,GAAG,2BACpE;AAGH,WACE,oCAAoC,IAAI,UAAU,cAAc,GAAG,iCACpE;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;EAMxC,MAAM,YAAY,IAAI,IACpB,iBAAiB,UAAU,MAAM,MAAM,MAAM,UAAU,CACxD;AAED,UAAM,oCAAoC,UAAU,SAAS;EAI7D,MAAM,UAAU,MAAO,IAAI,UAAU,IAAI,KACvCC,wCACA,eAAe,UAAU,YAAY,OAAO,KAAK;AAEnD,SAAO,IAAI,SAAS,QAAQ,MAAM;GAChC,SAAS,QAAQ;GACjB,QAAQ,QAAQ;GACjB,CAAC;;CAGJ,MAAMC,aAAgC,EACpC,UAAU,aACX;CAED,MAAMC,SAA2B;EAC/B,SAAS,YAAY;AACnB,UAAO,OAAO,YAAY,QAAQ;AAClC,UAAO,OAAO,WAAW,WAAW;AAEpC,UAAO;;EAET,GAAG;EACJ;AAED,aAAY,OAAO,OAAOC,SAAO,OAAO;AAExC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,MAAa,QAAQ,iBAAiB"}
+{"version":3,"file":"Fetch.cjs","names":["stepFetch: StepFetch","fetch: Fetch","getAsyncCtx","gatewaySymbol","optionsRef: StepFetch.Options","extras: StepFetch.Extras","fetch"],"sources":["../../src/components/Fetch.ts"],"sourcesContent":["import Debug from \"debug\";\nimport type { Simplify } from \"../helpers/types.ts\";\nimport { getAsyncCtx } from \"./execution/als.ts\";\nimport { gatewaySymbol, type InternalStepTools } from \"./InngestStepTools.ts\";\n\nconst globalFetch = globalThis.fetch;\ntype Fetch = typeof globalFetch;\n\nexport type StepFetch = Fetch &\n  Simplify<\n    {\n      config: (options: StepFetch.Options) => StepFetch;\n    } & Readonly<StepFetch.Options>\n  >;\n\nexport namespace StepFetch {\n  export interface Options {\n    fallback?: Fetch | undefined;\n  }\n\n  export interface Extras extends Options {\n    config: (options: Options) => StepFetch;\n  }\n}\n\nconst devDebug = Debug(\"inngest:fetch\");\n\nconst createFetchShim = (): StepFetch => {\n  // biome-ignore lint/style/useConst: need this to allow fns to be defined\n  let stepFetch: StepFetch;\n\n  const fetch: Fetch = async (input, init) => {\n    const ctx = await getAsyncCtx();\n    if (!ctx?.execution) {\n      // Not in a function run\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          \"step.fetch() called outside of a function and had no fallback set\",\n        );\n      }\n\n      devDebug(\n        \"step.fetch() called outside of a function; falling back to global fetch\",\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // In a function run\n    if (ctx.execution.executingStep) {\n      // Inside a step\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          `step.fetch() called inside step \"${ctx.execution.executingStep.id}\" and had no fallback set`,\n        );\n      }\n\n      devDebug(\n        `step.fetch() called inside step \"${ctx.execution.executingStep.id}\"; falling back to global fetch`,\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // TODO Do we need to make this better with deferred (global) step tooling?\n    // hmmmmm\n\n    const targetUrl = new URL(\n      input instanceof Request ? input.url : input.toString(),\n    );\n\n    devDebug(\"step.fetch() shimming request to\", targetUrl.hostname);\n\n    // Purposefully do not try/cacth this; if it throws then we treat that as a\n    // regular `fetch()` throw, which also would not return a `Response`.\n    const jsonRes = await (ctx.execution.ctx.step as InternalStepTools)[\n      gatewaySymbol\n    ](`step.fetch: ${targetUrl.hostname}`, input, init);\n\n    return new Response(jsonRes.body, {\n      headers: jsonRes.headers,\n      status: jsonRes.status_code,\n    });\n  };\n\n  const optionsRef: StepFetch.Options = {\n    fallback: globalFetch,\n  };\n\n  const extras: StepFetch.Extras = {\n    config: (options) => {\n      Object.assign(optionsRef, options);\n      Object.assign(stepFetch, optionsRef);\n\n      return stepFetch;\n    },\n    ...optionsRef,\n  };\n\n  stepFetch = Object.assign(fetch, extras);\n\n  return stepFetch;\n};\n\n/**\n * `fetch` is a Fetch API-compatible function that can be used to make any HTTP\n * code durable if it's called within an Inngest function.\n *\n * It will gracefully fall back to the global `fetch` if called outside of this\n * context, and a custom fallback can be set using the `config` method.\n *\n * @example Basic usage\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({ fetch });\n * ```\n *\n * @example Setting a custom fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: myCustomFetch }),\n * });\n * ```\n *\n * @example Do not allow fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: undefined }),\n * });\n * ```\n */\nexport const fetch = createFetchShim();\n"],"mappings":";;;;;;;AAKA,MAAM,cAAc,WAAW;AAoB/B,MAAM,8BAAiB,gBAAgB;AAEvC,MAAM,wBAAmC;CAEvC,IAAIA;CAEJ,MAAMC,UAAe,OAAO,OAAO,SAAS;EAC1C,MAAM,MAAM,MAAMC,yBAAa;AAC/B,MAAI,CAAC,KAAK,WAAW;AAEnB,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oEACD;AAGH,YACE,0EACD;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;AAIxC,MAAI,IAAI,UAAU,eAAe;AAE/B,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oCAAoC,IAAI,UAAU,cAAc,GAAG,2BACpE;AAGH,YACE,oCAAoC,IAAI,UAAU,cAAc,GAAG,iCACpE;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;EAMxC,MAAM,YAAY,IAAI,IACpB,iBAAiB,UAAU,MAAM,MAAM,MAAM,UAAU,CACxD;AAED,WAAS,oCAAoC,UAAU,SAAS;EAIhE,MAAM,UAAU,MAAO,IAAI,UAAU,IAAI,KACvCC,wCACA,eAAe,UAAU,YAAY,OAAO,KAAK;AAEnD,SAAO,IAAI,SAAS,QAAQ,MAAM;GAChC,SAAS,QAAQ;GACjB,QAAQ,QAAQ;GACjB,CAAC;;CAGJ,MAAMC,aAAgC,EACpC,UAAU,aACX;CAED,MAAMC,SAA2B;EAC/B,SAAS,YAAY;AACnB,UAAO,OAAO,YAAY,QAAQ;AAClC,UAAO,OAAO,WAAW,WAAW;AAEpC,UAAO;;EAET,GAAG;EACJ;AAED,aAAY,OAAO,OAAOC,SAAO,OAAO;AAExC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,MAAa,QAAQ,iBAAiB"}

package/components/Fetch.js

@@ -4,23 +4,23 @@ import Debug from "debug";
 
 //#region src/components/Fetch.ts
 const globalFetch = globalThis.fetch;
-const debug = Debug("inngest:fetch");
+const devDebug = Debug("inngest:fetch");
 const createFetchShim = () => {
 	let stepFetch;
 	const fetch$1 = async (input, init) => {
 		const ctx = await getAsyncCtx();
 		if (!ctx?.execution) {
 			if (!stepFetch.fallback) throw new Error("step.fetch() called outside of a function and had no fallback set");
-			debug("step.fetch() called outside of a function; falling back to global fetch");
+			devDebug("step.fetch() called outside of a function; falling back to global fetch");
 			return stepFetch.fallback(input, init);
 		}
 		if (ctx.execution.executingStep) {
 			if (!stepFetch.fallback) throw new Error(`step.fetch() called inside step "${ctx.execution.executingStep.id}" and had no fallback set`);
-			debug(`step.fetch() called inside step "${ctx.execution.executingStep.id}"; falling back to global fetch`);
+			devDebug(`step.fetch() called inside step "${ctx.execution.executingStep.id}"; falling back to global fetch`);
 			return stepFetch.fallback(input, init);
 		}
 		const targetUrl = new URL(input instanceof Request ? input.url : input.toString());
-		debug("step.fetch() shimming request to", targetUrl.hostname);
+		devDebug("step.fetch() shimming request to", targetUrl.hostname);
 		const jsonRes = await ctx.execution.ctx.step[gatewaySymbol](`step.fetch: ${targetUrl.hostname}`, input, init);
 		return new Response(jsonRes.body, {
 			headers: jsonRes.headers,

package/components/Fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"Fetch.js","names":["stepFetch: StepFetch","fetch: Fetch","optionsRef: StepFetch.Options","extras: StepFetch.Extras","fetch"],"sources":["../../src/components/Fetch.ts"],"sourcesContent":["import Debug from \"debug\";\nimport type { Simplify } from \"../helpers/types.ts\";\nimport { getAsyncCtx } from \"./execution/als.ts\";\nimport { gatewaySymbol, type InternalStepTools } from \"./InngestStepTools.ts\";\n\nconst globalFetch = globalThis.fetch;\ntype Fetch = typeof globalFetch;\n\nexport type StepFetch = Fetch &\n  Simplify<\n    {\n      config: (options: StepFetch.Options) => StepFetch;\n    } & Readonly<StepFetch.Options>\n  >;\n\nexport namespace StepFetch {\n  export interface Options {\n    fallback?: Fetch | undefined;\n  }\n\n  export interface Extras extends Options {\n    config: (options: Options) => StepFetch;\n  }\n}\n\nconst debug = Debug(\"inngest:fetch\");\n\nconst createFetchShim = (): StepFetch => {\n  // biome-ignore lint/style/useConst: need this to allow fns to be defined\n  let stepFetch: StepFetch;\n\n  const fetch: Fetch = async (input, init) => {\n    const ctx = await getAsyncCtx();\n    if (!ctx?.execution) {\n      // Not in a function run\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          \"step.fetch() called outside of a function and had no fallback set\",\n        );\n      }\n\n      debug(\n        \"step.fetch() called outside of a function; falling back to global fetch\",\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // In a function run\n    if (ctx.execution.executingStep) {\n      // Inside a step\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          `step.fetch() called inside step \"${ctx.execution.executingStep.id}\" and had no fallback set`,\n        );\n      }\n\n      debug(\n        `step.fetch() called inside step \"${ctx.execution.executingStep.id}\"; falling back to global fetch`,\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // TODO Do we need to make this better with deferred (global) step tooling?\n    // hmmmmm\n\n    const targetUrl = new URL(\n      input instanceof Request ? input.url : input.toString(),\n    );\n\n    debug(\"step.fetch() shimming request to\", targetUrl.hostname);\n\n    // Purposefully do not try/cacth this; if it throws then we treat that as a\n    // regular `fetch()` throw, which also would not return a `Response`.\n    const jsonRes = await (ctx.execution.ctx.step as InternalStepTools)[\n      gatewaySymbol\n    ](`step.fetch: ${targetUrl.hostname}`, input, init);\n\n    return new Response(jsonRes.body, {\n      headers: jsonRes.headers,\n      status: jsonRes.status_code,\n    });\n  };\n\n  const optionsRef: StepFetch.Options = {\n    fallback: globalFetch,\n  };\n\n  const extras: StepFetch.Extras = {\n    config: (options) => {\n      Object.assign(optionsRef, options);\n      Object.assign(stepFetch, optionsRef);\n\n      return stepFetch;\n    },\n    ...optionsRef,\n  };\n\n  stepFetch = Object.assign(fetch, extras);\n\n  return stepFetch;\n};\n\n/**\n * `fetch` is a Fetch API-compatible function that can be used to make any HTTP\n * code durable if it's called within an Inngest function.\n *\n * It will gracefully fall back to the global `fetch` if called outside of this\n * context, and a custom fallback can be set using the `config` method.\n *\n * @example Basic usage\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({ fetch });\n * ```\n *\n * @example Setting a custom fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: myCustomFetch }),\n * });\n * ```\n *\n * @example Do not allow fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: undefined }),\n * });\n * ```\n */\nexport const fetch = createFetchShim();\n"],"mappings":";;;;;AAKA,MAAM,cAAc,WAAW;AAoB/B,MAAM,QAAQ,MAAM,gBAAgB;AAEpC,MAAM,wBAAmC;CAEvC,IAAIA;CAEJ,MAAMC,UAAe,OAAO,OAAO,SAAS;EAC1C,MAAM,MAAM,MAAM,aAAa;AAC/B,MAAI,CAAC,KAAK,WAAW;AAEnB,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oEACD;AAGH,SACE,0EACD;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;AAIxC,MAAI,IAAI,UAAU,eAAe;AAE/B,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oCAAoC,IAAI,UAAU,cAAc,GAAG,2BACpE;AAGH,SACE,oCAAoC,IAAI,UAAU,cAAc,GAAG,iCACpE;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;EAMxC,MAAM,YAAY,IAAI,IACpB,iBAAiB,UAAU,MAAM,MAAM,MAAM,UAAU,CACxD;AAED,QAAM,oCAAoC,UAAU,SAAS;EAI7D,MAAM,UAAU,MAAO,IAAI,UAAU,IAAI,KACvC,eACA,eAAe,UAAU,YAAY,OAAO,KAAK;AAEnD,SAAO,IAAI,SAAS,QAAQ,MAAM;GAChC,SAAS,QAAQ;GACjB,QAAQ,QAAQ;GACjB,CAAC;;CAGJ,MAAMC,aAAgC,EACpC,UAAU,aACX;CAED,MAAMC,SAA2B;EAC/B,SAAS,YAAY;AACnB,UAAO,OAAO,YAAY,QAAQ;AAClC,UAAO,OAAO,WAAW,WAAW;AAEpC,UAAO;;EAET,GAAG;EACJ;AAED,aAAY,OAAO,OAAOC,SAAO,OAAO;AAExC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,MAAa,QAAQ,iBAAiB"}
+{"version":3,"file":"Fetch.js","names":["stepFetch: StepFetch","fetch: Fetch","optionsRef: StepFetch.Options","extras: StepFetch.Extras","fetch"],"sources":["../../src/components/Fetch.ts"],"sourcesContent":["import Debug from \"debug\";\nimport type { Simplify } from \"../helpers/types.ts\";\nimport { getAsyncCtx } from \"./execution/als.ts\";\nimport { gatewaySymbol, type InternalStepTools } from \"./InngestStepTools.ts\";\n\nconst globalFetch = globalThis.fetch;\ntype Fetch = typeof globalFetch;\n\nexport type StepFetch = Fetch &\n  Simplify<\n    {\n      config: (options: StepFetch.Options) => StepFetch;\n    } & Readonly<StepFetch.Options>\n  >;\n\nexport namespace StepFetch {\n  export interface Options {\n    fallback?: Fetch | undefined;\n  }\n\n  export interface Extras extends Options {\n    config: (options: Options) => StepFetch;\n  }\n}\n\nconst devDebug = Debug(\"inngest:fetch\");\n\nconst createFetchShim = (): StepFetch => {\n  // biome-ignore lint/style/useConst: need this to allow fns to be defined\n  let stepFetch: StepFetch;\n\n  const fetch: Fetch = async (input, init) => {\n    const ctx = await getAsyncCtx();\n    if (!ctx?.execution) {\n      // Not in a function run\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          \"step.fetch() called outside of a function and had no fallback set\",\n        );\n      }\n\n      devDebug(\n        \"step.fetch() called outside of a function; falling back to global fetch\",\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // In a function run\n    if (ctx.execution.executingStep) {\n      // Inside a step\n      if (!stepFetch.fallback) {\n        // TODO Tell the user how to solve\n        throw new Error(\n          `step.fetch() called inside step \"${ctx.execution.executingStep.id}\" and had no fallback set`,\n        );\n      }\n\n      devDebug(\n        `step.fetch() called inside step \"${ctx.execution.executingStep.id}\"; falling back to global fetch`,\n      );\n\n      return stepFetch.fallback(input, init);\n    }\n\n    // TODO Do we need to make this better with deferred (global) step tooling?\n    // hmmmmm\n\n    const targetUrl = new URL(\n      input instanceof Request ? input.url : input.toString(),\n    );\n\n    devDebug(\"step.fetch() shimming request to\", targetUrl.hostname);\n\n    // Purposefully do not try/cacth this; if it throws then we treat that as a\n    // regular `fetch()` throw, which also would not return a `Response`.\n    const jsonRes = await (ctx.execution.ctx.step as InternalStepTools)[\n      gatewaySymbol\n    ](`step.fetch: ${targetUrl.hostname}`, input, init);\n\n    return new Response(jsonRes.body, {\n      headers: jsonRes.headers,\n      status: jsonRes.status_code,\n    });\n  };\n\n  const optionsRef: StepFetch.Options = {\n    fallback: globalFetch,\n  };\n\n  const extras: StepFetch.Extras = {\n    config: (options) => {\n      Object.assign(optionsRef, options);\n      Object.assign(stepFetch, optionsRef);\n\n      return stepFetch;\n    },\n    ...optionsRef,\n  };\n\n  stepFetch = Object.assign(fetch, extras);\n\n  return stepFetch;\n};\n\n/**\n * `fetch` is a Fetch API-compatible function that can be used to make any HTTP\n * code durable if it's called within an Inngest function.\n *\n * It will gracefully fall back to the global `fetch` if called outside of this\n * context, and a custom fallback can be set using the `config` method.\n *\n * @example Basic usage\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({ fetch });\n * ```\n *\n * @example Setting a custom fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: myCustomFetch }),\n * });\n * ```\n *\n * @example Do not allow fallback\n * ```ts\n * import { fetch } from \"inngest\";\n *\n * const api = new MyProductApi({\n *            fetch: fetch.config({ fallback: undefined }),\n * });\n * ```\n */\nexport const fetch = createFetchShim();\n"],"mappings":";;;;;AAKA,MAAM,cAAc,WAAW;AAoB/B,MAAM,WAAW,MAAM,gBAAgB;AAEvC,MAAM,wBAAmC;CAEvC,IAAIA;CAEJ,MAAMC,UAAe,OAAO,OAAO,SAAS;EAC1C,MAAM,MAAM,MAAM,aAAa;AAC/B,MAAI,CAAC,KAAK,WAAW;AAEnB,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oEACD;AAGH,YACE,0EACD;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;AAIxC,MAAI,IAAI,UAAU,eAAe;AAE/B,OAAI,CAAC,UAAU,SAEb,OAAM,IAAI,MACR,oCAAoC,IAAI,UAAU,cAAc,GAAG,2BACpE;AAGH,YACE,oCAAoC,IAAI,UAAU,cAAc,GAAG,iCACpE;AAED,UAAO,UAAU,SAAS,OAAO,KAAK;;EAMxC,MAAM,YAAY,IAAI,IACpB,iBAAiB,UAAU,MAAM,MAAM,MAAM,UAAU,CACxD;AAED,WAAS,oCAAoC,UAAU,SAAS;EAIhE,MAAM,UAAU,MAAO,IAAI,UAAU,IAAI,KACvC,eACA,eAAe,UAAU,YAAY,OAAO,KAAK;AAEnD,SAAO,IAAI,SAAS,QAAQ,MAAM;GAChC,SAAS,QAAQ;GACjB,QAAQ,QAAQ;GACjB,CAAC;;CAGJ,MAAMC,aAAgC,EACpC,UAAU,aACX;CAED,MAAMC,SAA2B;EAC/B,SAAS,YAAY;AACnB,UAAO,OAAO,YAAY,QAAQ;AAClC,UAAO,OAAO,WAAW,WAAW;AAEpC,UAAO;;EAET,GAAG;EACJ;AAED,aAAY,OAAO,OAAOC,SAAO,OAAO;AAExC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,MAAa,QAAQ,iBAAiB"}

package/components/InngestCommHandler.cjs

@@ -626,6 +626,7 @@ var InngestCommHandler = class {
 				fn,
 				handler: innerHandler,
 				middleware: mwInstances,
+				requestArgs: args,
 				requestInfo,
 				runId
 			})();
@@ -1354,11 +1355,11 @@ var InngestCommHandler = class {
 	*/
 	checkModeConfiguration() {
 		this.client.setEnvVars(this.env);
-		if (this.client.mode === "cloud" && !this.client.signingKey) {
-			this.client[require_Inngest.internalLoggerSymbol].error(`In cloud mode but no signing key found. For local dev, set the INNGEST_DEV=1 env var. For production, set the ${require_consts.envKeys.InngestSigningKey} env var`);
-			return false;
-		}
-		return true;
+		return require_env.checkModeConfiguration({
+			mode: this.client.mode,
+			signingKey: this.client.signingKey,
+			internalLogger: this.client[require_Inngest.internalLoggerSymbol]
+		});
 	}
 	/**
 	* Validate the signature of a request and return the signing key used to