inngest 4.1.2 → 4.2.0

package/components/StreamTools.js

@@ -0,0 +1,240 @@
+import { getAsyncCtx, getAsyncCtxSync } from "./execution/als.js";
+import { buildSseCommitEvent, buildSseFailedEvent, buildSseRedirectEvent, buildSseRollbackEvent, buildSseStreamEvent, buildSseSucceededEvent } from "./execution/streaming.js";
+
+//#region src/components/StreamTools.ts
+/**
+* Wraps a `TransformStream<Uint8Array>` to provide push/pipe SSE streaming
+* capabilities within an Inngest execution.
+*
+* @internal
+*/
+var Stream = class {
+	transform;
+	writer;
+	encoder = new TextEncoder();
+	_activated = false;
+	_errored = false;
+	writeChain = Promise.resolve();
+	/**
+	* Optional callback invoked the first time `push` or `pipe` is called.
+	* Used by the execution engine to fire a checkpoint that returns the SSE
+	* Response to the client immediately.
+	*/
+	onActivated;
+	/**
+	* Optional callback invoked when a write to the underlying stream fails
+	* (e.g. the client disconnected or the transform stream errored). Used by
+	* the execution engine to emit diagnostic logs.
+	*/
+	onWriteError;
+	constructor(opts) {
+		this.onActivated = opts?.onActivated;
+		this.onWriteError = opts?.onWriteError;
+		this.transform = new TransformStream(void 0, void 0, new CountQueuingStrategy({ highWaterMark: 1024 }));
+		this.writer = this.transform.writable.getWriter();
+	}
+	/**
+	* Whether `push` or `pipe` has been called at least once.
+	*/
+	get activated() {
+		return this._activated;
+	}
+	/**
+	* The readable side of the underlying transform stream. Consumers (i.e. the
+	* HTTP response) read SSE events from here.
+	*/
+	get readable() {
+		return this.transform.readable;
+	}
+	/**
+	* Resolve the current hashed step ID for stream events. Returns the
+	* executing step's hashed ID (read from ALS), or undefined if outside a step.
+	*/
+	currentHashedStepId() {
+		return getAsyncCtxSync()?.execution?.executingStep?.hashedId;
+	}
+	activate() {
+		if (!this._activated) {
+			this._activated = true;
+			this.onActivated?.();
+		}
+	}
+	/**
+	* Encode and write an SSE event string to the underlying writer.
+	*/
+	writeEncoded(sseEvent) {
+		return this.writer.write(this.encoder.encode(sseEvent));
+	}
+	/**
+	* Enqueue a pre-built SSE event string onto the write chain.
+	*/
+	enqueue(sseEvent) {
+		if (this._errored) return;
+		this.writeChain = this.writeChain.then(() => this.writeEncoded(sseEvent)).catch((err) => {
+			this._errored = true;
+			this.onWriteError?.(err);
+		});
+	}
+	/**
+	* Emit an `inngest.commit` SSE event indicating that uncommitted streamed data
+	* should be committed (i.e. will not be rolled back). Internal use only.
+	*/
+	commit(hashedStepId) {
+		this.enqueue(buildSseCommitEvent(hashedStepId));
+	}
+	/**
+	* Emit an `inngest.rollback` SSE event indicating the uncommitted streamed
+	* data should be discarded (e.g. step errored). Internal use only.
+	*/
+	rollback(hashedStepId) {
+		this.enqueue(buildSseRollbackEvent(hashedStepId));
+	}
+	/**
+	* Serialize `data` into an SSE stream event and enqueue it. Returns `false`
+	* if serialization fails (e.g. circular reference) so callers can skip.
+	*/
+	enqueueStreamEvent(data, hashedStepId) {
+		let sseEvent;
+		try {
+			sseEvent = buildSseStreamEvent(data, hashedStepId);
+		} catch {
+			return false;
+		}
+		this.enqueue(sseEvent);
+		return true;
+	}
+	/**
+	* Write a single SSE stream event containing `data`. The current step's
+	* hashed ID is automatically included as stepId for rollback tracking.
+	*/
+	push(data) {
+		this.activate();
+		this.enqueueStreamEvent(data, this.currentHashedStepId());
+	}
+	/**
+	* Pipe a source to the client, writing each chunk as an SSE stream event.
+	* Returns the concatenated content of all chunks.
+	*/
+	async pipe(source) {
+		this.activate();
+		let iterable;
+		if (source instanceof ReadableStream) iterable = this.readableToAsyncIterable(source);
+		else if (typeof source === "function") iterable = source();
+		else iterable = source;
+		return this.pipeIterable(iterable);
+	}
+	/**
+	* Adapt a ReadableStream into an AsyncIterable<string>. TypeScript's
+	* ReadableStream type doesn't declare Symbol.asyncIterator, so we use the
+	* reader API for type safety.
+	*/
+	async *readableToAsyncIterable(readable) {
+		const reader = readable.getReader();
+		const decoder = new TextDecoder();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				yield typeof value === "string" ? value : decoder.decode(value, { stream: true });
+			}
+			const final = decoder.decode();
+			if (final) yield final;
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	/**
+	* Core pipe loop: iterate an async iterable, writing each chunk as an SSE
+	* stream event and collecting the concatenated result.
+	*/
+	async pipeIterable(source) {
+		const hashedStepId = this.currentHashedStepId();
+		const chunks = [];
+		for await (const chunk of source) {
+			if (this._errored) break;
+			chunks.push(chunk);
+			if (!this.enqueueStreamEvent(chunk, hashedStepId)) continue;
+			await this.writeChain;
+		}
+		return chunks.join("");
+	}
+	/**
+	* Write a redirect info event. Tells the client where to reconnect if the
+	* durable endpoint goes async. Does NOT close the writer — more stream
+	* events may follow before the durable endpoint actually switches to async
+	* mode. Internal use only.
+	*/
+	sendRedirectInfo(data) {
+		this.enqueue(buildSseRedirectEvent(data));
+	}
+	/**
+	* Write a succeeded result event and close the writer. Internal use only.
+	*/
+	closeSucceeded(response) {
+		let sseEvent;
+		try {
+			sseEvent = buildSseSucceededEvent(response);
+		} catch {
+			sseEvent = buildSseFailedEvent("Failed to serialize result");
+		}
+		this.closeWriter(sseEvent);
+	}
+	/**
+	* Write a failed result event and close the writer. Internal use only.
+	*/
+	closeFailed(error) {
+		this.closeWriter(buildSseFailedEvent(error));
+	}
+	/**
+	* Optionally write a final SSE event, then close the writer.
+	*/
+	closeWriter(finalEvent) {
+		this.writeChain = this.writeChain.then(async () => {
+			if (finalEvent) await this.writeEncoded(finalEvent);
+			await this.writer.close();
+		}).catch((err) => {
+			this.onWriteError?.(err);
+		});
+	}
+	/**
+	* Close the writer without writing a result event. Used when the durable endpoint goes
+	* async and the real result will arrive on the redirected stream.
+	*/
+	end() {
+		this.closeWriter();
+	}
+};
+/** Synchronous ALS lookup for the stream tools (fast path). */
+const getStreamToolsSync = () => {
+	return getAsyncCtxSync()?.execution?.stream;
+};
+const getDeferredStreamTooling = async () => {
+	return (await getAsyncCtx())?.execution?.stream;
+};
+/**
+* Stream tools that use ALS to resolve the current execution context.
+* Outside an Inngest execution, `push()` is a no-op and `pipe()` resolves immediately.
+*/
+const stream = {
+	push: (data) => {
+		const syncStream = getStreamToolsSync();
+		if (syncStream) {
+			syncStream.push(data);
+			return;
+		}
+		getDeferredStreamTooling().then((s) => {
+			s?.push(data);
+		}).catch(() => {});
+	},
+	pipe: async (source) => {
+		const syncStream = getStreamToolsSync();
+		if (syncStream) return syncStream.pipe(source);
+		const s = await getDeferredStreamTooling();
+		if (s) return s.pipe(source);
+		return "";
+	}
+};
+
+//#endregion
+export { Stream, stream };
+//# sourceMappingURL=StreamTools.js.map

package/components/StreamTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamTools.js","names":["sseEvent: string","iterable: AsyncIterable<string>","chunks: string[]","stream: StreamTools"],"sources":["../../src/components/StreamTools.ts"],"sourcesContent":["import { getAsyncCtx, getAsyncCtxSync } from \"./execution/als.ts\";\nimport {\n  buildSseCommitEvent,\n  buildSseFailedEvent,\n  buildSseRedirectEvent,\n  buildSseRollbackEvent,\n  buildSseStreamEvent,\n  buildSseSucceededEvent,\n  type SseResponse,\n} from \"./execution/streaming.ts\";\n\n/**\n * Accepted source types for `stream.pipe()`.\n *\n * - `ReadableStream` — piped directly\n * - `AsyncIterable<string>` — iterated; each yielded value becomes a chunk\n * - `() => AsyncIterable<string>` — factory invoked lazily, then iterated\n */\nexport type PipeSource =\n  | ReadableStream\n  | AsyncIterable<string>\n  | (() => AsyncIterable<string>);\n\n/**\n * The public interface for stream tools available to user code.\n */\nexport interface StreamTools {\n  /**\n   * Push data to the client as an SSE stream event. Fire-and-forget from the\n   * caller's perspective.\n   *\n   * Outside of an Inngest execution context this is a silent no-op (graceful\n   * degradation).\n   */\n  push(data: unknown): void;\n\n  /**\n   * Pipe a source to the client, writing each chunk as an SSE stream event.\n   * Resolves with the concatenated content of all chunks when the source is\n   * fully consumed.\n   *\n   * Accepts a `ReadableStream`, an `AsyncIterable<string>`, or a factory\n   * function that returns an `AsyncIterable<string>` (e.g. an async\n   * generator function).\n   *\n   * Outside of an Inngest execution context this resolves with an empty string.\n   */\n  pipe(source: PipeSource): Promise<string>;\n}\n\n/**\n * Wraps a `TransformStream<Uint8Array>` to provide push/pipe SSE streaming\n * capabilities within an Inngest execution.\n *\n * @internal\n */\nexport class Stream implements StreamTools {\n  private transform: TransformStream<Uint8Array, Uint8Array>;\n  private writer: WritableStreamDefaultWriter<Uint8Array>;\n  private encoder = new TextEncoder();\n  private _activated = false;\n  private _errored = false;\n  private writeChain: Promise<void> = Promise.resolve();\n\n  /**\n   * Optional callback invoked the first time `push` or `pipe` is called.\n   * Used by the execution engine to fire a checkpoint that returns the SSE\n   * Response to the client immediately.\n   */\n  private onActivated?: () => void;\n\n  /**\n   * Optional callback invoked when a write to the underlying stream fails\n   * (e.g. the client disconnected or the transform stream errored). Used by\n   * the execution engine to emit diagnostic logs.\n   */\n  private onWriteError?: (err: unknown) => void;\n\n  constructor(opts?: {\n    onActivated?: () => void;\n    onWriteError?: (err: unknown) => void;\n  }) {\n    this.onActivated = opts?.onActivated;\n    this.onWriteError = opts?.onWriteError;\n    this.transform = new TransformStream<Uint8Array, Uint8Array>(\n      undefined,\n      undefined,\n      // Use a generous high water mark on the readable side so that writes\n      // don't block due to backpressure before the consumer reads.\n      new CountQueuingStrategy({ highWaterMark: 1024 }),\n    );\n    this.writer = this.transform.writable.getWriter();\n  }\n\n  /**\n   * Whether `push` or `pipe` has been called at least once.\n   */\n  get activated(): boolean {\n    return this._activated;\n  }\n\n  /**\n   * The readable side of the underlying transform stream. Consumers (i.e. the\n   * HTTP response) read SSE events from here.\n   */\n  get readable(): ReadableStream<Uint8Array> {\n    return this.transform.readable;\n  }\n\n  /**\n   * Resolve the current hashed step ID for stream events. Returns the\n   * executing step's hashed ID (read from ALS), or undefined if outside a step.\n   */\n  private currentHashedStepId(): string | undefined {\n    return getAsyncCtxSync()?.execution?.executingStep?.hashedId;\n  }\n\n  private activate(): void {\n    if (!this._activated) {\n      this._activated = true;\n      this.onActivated?.();\n    }\n  }\n\n  /**\n   * Encode and write an SSE event string to the underlying writer.\n   */\n  private writeEncoded(sseEvent: string): Promise<void> {\n    return this.writer.write(this.encoder.encode(sseEvent));\n  }\n\n  /**\n   * Enqueue a pre-built SSE event string onto the write chain.\n   */\n  private enqueue(sseEvent: string): void {\n    if (this._errored) return;\n\n    this.writeChain = this.writeChain\n      .then(() => this.writeEncoded(sseEvent))\n      .catch((err) => {\n        // Writer errored (e.g. stream closed) — swallow so the chain\n        // doesn't break and subsequent writes fail gracefully.\n        this._errored = true;\n        this.onWriteError?.(err);\n      });\n  }\n\n  /**\n   * Emit an `inngest.commit` SSE event indicating that uncommitted streamed data\n   * should be committed (i.e. will not be rolled back). Internal use only.\n   */\n  commit(hashedStepId: string | null): void {\n    this.enqueue(buildSseCommitEvent(hashedStepId));\n  }\n\n  /**\n   * Emit an `inngest.rollback` SSE event indicating the uncommitted streamed\n   * data should be discarded (e.g. step errored). Internal use only.\n   */\n  rollback(hashedStepId: string | null): void {\n    this.enqueue(buildSseRollbackEvent(hashedStepId));\n  }\n\n  /**\n   * Serialize `data` into an SSE stream event and enqueue it. Returns `false`\n   * if serialization fails (e.g. circular reference) so callers can skip.\n   */\n  private enqueueStreamEvent(data: unknown, hashedStepId?: string): boolean {\n    let sseEvent: string;\n    try {\n      sseEvent = buildSseStreamEvent(data, hashedStepId);\n    } catch {\n      return false;\n    }\n\n    this.enqueue(sseEvent);\n    return true;\n  }\n\n  /**\n   * Write a single SSE stream event containing `data`. The current step's\n   * hashed ID is automatically included as stepId for rollback tracking.\n   */\n  push(data: unknown): void {\n    this.activate();\n    this.enqueueStreamEvent(data, this.currentHashedStepId());\n  }\n\n  /**\n   * Pipe a source to the client, writing each chunk as an SSE stream event.\n   * Returns the concatenated content of all chunks.\n   */\n  async pipe(source: PipeSource): Promise<string> {\n    this.activate();\n\n    let iterable: AsyncIterable<string>;\n    if (source instanceof ReadableStream) {\n      iterable = this.readableToAsyncIterable(source);\n    } else if (typeof source === \"function\") {\n      iterable = source();\n    } else {\n      iterable = source;\n    }\n\n    return this.pipeIterable(iterable);\n  }\n\n  /**\n   * Adapt a ReadableStream into an AsyncIterable<string>. TypeScript's\n   * ReadableStream type doesn't declare Symbol.asyncIterator, so we use the\n   * reader API for type safety.\n   */\n  private async *readableToAsyncIterable(\n    readable: ReadableStream,\n  ): AsyncIterable<string> {\n    const reader = readable.getReader();\n    const decoder = new TextDecoder();\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        yield typeof value === \"string\"\n          ? value\n          : decoder.decode(value, { stream: true });\n      }\n      // flush any partially buffered multibyte characters from the decoder\n      const final = decoder.decode();\n      if (final) yield final;\n    } finally {\n      reader.releaseLock();\n    }\n  }\n\n  /**\n   * Core pipe loop: iterate an async iterable, writing each chunk as an SSE\n   * stream event and collecting the concatenated result.\n   */\n  private async pipeIterable(source: AsyncIterable<string>): Promise<string> {\n    const hashedStepId = this.currentHashedStepId();\n    const chunks: string[] = [];\n\n    for await (const chunk of source) {\n      if (this._errored) break;\n\n      chunks.push(chunk);\n\n      if (!this.enqueueStreamEvent(chunk, hashedStepId)) {\n        continue;\n      }\n\n      await this.writeChain;\n    }\n\n    return chunks.join(\"\");\n  }\n\n  /**\n   * Write a redirect info event. Tells the client where to reconnect if the\n   * durable endpoint goes async. Does NOT close the writer — more stream\n   * events may follow before the durable endpoint actually switches to async\n   * mode. Internal use only.\n   */\n  sendRedirectInfo(data: { runId: string; url: string }): void {\n    this.enqueue(buildSseRedirectEvent(data));\n  }\n\n  /**\n   * Write a succeeded result event and close the writer. Internal use only.\n   */\n  closeSucceeded(response: SseResponse): void {\n    let sseEvent: string;\n    try {\n      sseEvent = buildSseSucceededEvent(response);\n    } catch {\n      sseEvent = buildSseFailedEvent(\"Failed to serialize result\");\n    }\n    this.closeWriter(sseEvent);\n  }\n\n  /**\n   * Write a failed result event and close the writer. Internal use only.\n   */\n  closeFailed(error: string): void {\n    this.closeWriter(buildSseFailedEvent(error));\n  }\n\n  /**\n   * Optionally write a final SSE event, then close the writer.\n   */\n  private closeWriter(finalEvent?: string): void {\n    this.writeChain = this.writeChain\n      .then(async () => {\n        if (finalEvent) {\n          await this.writeEncoded(finalEvent);\n        }\n        await this.writer.close();\n      })\n      .catch((err) => {\n        this.onWriteError?.(err);\n      });\n  }\n\n  /**\n   * Close the writer without writing a result event. Used when the durable endpoint goes\n   * async and the real result will arrive on the redirected stream.\n   */\n  end(): void {\n    this.closeWriter();\n  }\n}\n\n/** Synchronous ALS lookup for the stream tools (fast path). */\nconst getStreamToolsSync = (): Stream | undefined => {\n  const ctx = getAsyncCtxSync();\n  return ctx?.execution?.stream;\n};\n\nconst getDeferredStreamTooling = async (): Promise<Stream | undefined> => {\n  const ctx = await getAsyncCtx();\n  return ctx?.execution?.stream;\n};\n\n/**\n * Stream tools that use ALS to resolve the current execution context.\n * Outside an Inngest execution, `push()` is a no-op and `pipe()` resolves immediately.\n */\nexport const stream: StreamTools = {\n  push: (data) => {\n    // Sync fast path: activate the stream before the next microtask tick.\n    const syncStream = getStreamToolsSync();\n    if (syncStream) {\n      syncStream.push(data);\n      return;\n    }\n\n    // Fallback: ALS not yet initialized (first import still resolving).\n    void getDeferredStreamTooling()\n      .then((s) => {\n        s?.push(data);\n      })\n      .catch(() => {\n        // ALS initialization failure — already warned in als.ts.\n        // push() is best-effort, so silently degrade.\n      });\n  },\n  pipe: async (source) => {\n    const syncStream = getStreamToolsSync();\n    if (syncStream) {\n      return syncStream.pipe(source);\n    }\n\n    const s = await getDeferredStreamTooling();\n    if (s) {\n      return s.pipe(source);\n    }\n    return \"\";\n  },\n};\n"],"mappings":";;;;;;;;;;AAwDA,IAAa,SAAb,MAA2C;CACzC,AAAQ;CACR,AAAQ;CACR,AAAQ,UAAU,IAAI,aAAa;CACnC,AAAQ,aAAa;CACrB,AAAQ,WAAW;CACnB,AAAQ,aAA4B,QAAQ,SAAS;;;;;;CAOrD,AAAQ;;;;;;CAOR,AAAQ;CAER,YAAY,MAGT;AACD,OAAK,cAAc,MAAM;AACzB,OAAK,eAAe,MAAM;AAC1B,OAAK,YAAY,IAAI,gBACnB,QACA,QAGA,IAAI,qBAAqB,EAAE,eAAe,MAAM,CAAC,CAClD;AACD,OAAK,SAAS,KAAK,UAAU,SAAS,WAAW;;;;;CAMnD,IAAI,YAAqB;AACvB,SAAO,KAAK;;;;;;CAOd,IAAI,WAAuC;AACzC,SAAO,KAAK,UAAU;;;;;;CAOxB,AAAQ,sBAA0C;AAChD,SAAO,iBAAiB,EAAE,WAAW,eAAe;;CAGtD,AAAQ,WAAiB;AACvB,MAAI,CAAC,KAAK,YAAY;AACpB,QAAK,aAAa;AAClB,QAAK,eAAe;;;;;;CAOxB,AAAQ,aAAa,UAAiC;AACpD,SAAO,KAAK,OAAO,MAAM,KAAK,QAAQ,OAAO,SAAS,CAAC;;;;;CAMzD,AAAQ,QAAQ,UAAwB;AACtC,MAAI,KAAK,SAAU;AAEnB,OAAK,aAAa,KAAK,WACpB,WAAW,KAAK,aAAa,SAAS,CAAC,CACvC,OAAO,QAAQ;AAGd,QAAK,WAAW;AAChB,QAAK,eAAe,IAAI;IACxB;;;;;;CAON,OAAO,cAAmC;AACxC,OAAK,QAAQ,oBAAoB,aAAa,CAAC;;;;;;CAOjD,SAAS,cAAmC;AAC1C,OAAK,QAAQ,sBAAsB,aAAa,CAAC;;;;;;CAOnD,AAAQ,mBAAmB,MAAe,cAAgC;EACxE,IAAIA;AACJ,MAAI;AACF,cAAW,oBAAoB,MAAM,aAAa;UAC5C;AACN,UAAO;;AAGT,OAAK,QAAQ,SAAS;AACtB,SAAO;;;;;;CAOT,KAAK,MAAqB;AACxB,OAAK,UAAU;AACf,OAAK,mBAAmB,MAAM,KAAK,qBAAqB,CAAC;;;;;;CAO3D,MAAM,KAAK,QAAqC;AAC9C,OAAK,UAAU;EAEf,IAAIC;AACJ,MAAI,kBAAkB,eACpB,YAAW,KAAK,wBAAwB,OAAO;WACtC,OAAO,WAAW,WAC3B,YAAW,QAAQ;MAEnB,YAAW;AAGb,SAAO,KAAK,aAAa,SAAS;;;;;;;CAQpC,OAAe,wBACb,UACuB;EACvB,MAAM,SAAS,SAAS,WAAW;EACnC,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI;AACF,UAAO,MAAM;IACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,QAAI,KAAM;AACV,UAAM,OAAO,UAAU,WACnB,QACA,QAAQ,OAAO,OAAO,EAAE,QAAQ,MAAM,CAAC;;GAG7C,MAAM,QAAQ,QAAQ,QAAQ;AAC9B,OAAI,MAAO,OAAM;YACT;AACR,UAAO,aAAa;;;;;;;CAQxB,MAAc,aAAa,QAAgD;EACzE,MAAM,eAAe,KAAK,qBAAqB;EAC/C,MAAMC,SAAmB,EAAE;AAE3B,aAAW,MAAM,SAAS,QAAQ;AAChC,OAAI,KAAK,SAAU;AAEnB,UAAO,KAAK,MAAM;AAElB,OAAI,CAAC,KAAK,mBAAmB,OAAO,aAAa,CAC/C;AAGF,SAAM,KAAK;;AAGb,SAAO,OAAO,KAAK,GAAG;;;;;;;;CASxB,iBAAiB,MAA4C;AAC3D,OAAK,QAAQ,sBAAsB,KAAK,CAAC;;;;;CAM3C,eAAe,UAA6B;EAC1C,IAAIF;AACJ,MAAI;AACF,cAAW,uBAAuB,SAAS;UACrC;AACN,cAAW,oBAAoB,6BAA6B;;AAE9D,OAAK,YAAY,SAAS;;;;;CAM5B,YAAY,OAAqB;AAC/B,OAAK,YAAY,oBAAoB,MAAM,CAAC;;;;;CAM9C,AAAQ,YAAY,YAA2B;AAC7C,OAAK,aAAa,KAAK,WACpB,KAAK,YAAY;AAChB,OAAI,WACF,OAAM,KAAK,aAAa,WAAW;AAErC,SAAM,KAAK,OAAO,OAAO;IACzB,CACD,OAAO,QAAQ;AACd,QAAK,eAAe,IAAI;IACxB;;;;;;CAON,MAAY;AACV,OAAK,aAAa;;;;AAKtB,MAAM,2BAA+C;AAEnD,QADY,iBAAiB,EACjB,WAAW;;AAGzB,MAAM,2BAA2B,YAAyC;AAExE,SADY,MAAM,aAAa,GACnB,WAAW;;;;;;AAOzB,MAAaG,SAAsB;CACjC,OAAO,SAAS;EAEd,MAAM,aAAa,oBAAoB;AACvC,MAAI,YAAY;AACd,cAAW,KAAK,KAAK;AACrB;;AAIF,EAAK,0BAA0B,CAC5B,MAAM,MAAM;AACX,MAAG,KAAK,KAAK;IACb,CACD,YAAY,GAGX;;CAEN,MAAM,OAAO,WAAW;EACtB,MAAM,aAAa,oBAAoB;AACvC,MAAI,WACF,QAAO,WAAW,KAAK,OAAO;EAGhC,MAAM,IAAI,MAAM,0BAA0B;AAC1C,MAAI,EACF,QAAO,EAAE,KAAK,OAAO;AAEvB,SAAO;;CAEV"}

package/components/createWebApiCommHandler.cjs

@@ -0,0 +1,46 @@
+const require_InngestCommHandler = require('./InngestCommHandler.cjs');
+
+//#region src/components/createWebApiCommHandler.ts
+/**
+* Creates an {@link InngestCommHandler} that uses Web API `Request`/`Response`.
+*
+* This is shared by the edge and Node.js adapters so the handler logic isn't
+* duplicated.
+*/
+const createWebApiCommHandler = (frameworkName, options, syncOptions) => {
+	return new require_InngestCommHandler.InngestCommHandler({
+		frameworkName,
+		...options,
+		syncOptions,
+		handler: (req) => {
+			return {
+				body: () => req.text(),
+				headers: (key) => req.headers.get(key),
+				method: () => req.method,
+				url: () => new URL(req.url, `https://${req.headers.get("host") || ""}`),
+				transformResponse: ({ body, status, headers }) => {
+					return new Response(body, {
+						status,
+						headers
+					});
+				},
+				experimentalTransformSyncResponse: async (data) => {
+					const res = data;
+					const headers = {};
+					res.headers.forEach((v, k) => {
+						headers[k] = v;
+					});
+					return {
+						headers,
+						status: res.status,
+						body: await res.clone().text()
+					};
+				}
+			};
+		}
+	});
+};
+
+//#endregion
+exports.createWebApiCommHandler = createWebApiCommHandler;
+//# sourceMappingURL=createWebApiCommHandler.cjs.map

package/components/createWebApiCommHandler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWebApiCommHandler.cjs","names":["InngestCommHandler","headers: Record<string, string>"],"sources":["../../src/components/createWebApiCommHandler.ts"],"sourcesContent":["import type { RegisterOptions, SupportedFrameworkName } from \"../types.ts\";\nimport type { Inngest } from \"./Inngest.ts\";\nimport {\n  InngestCommHandler,\n  type SyncHandlerOptions,\n} from \"./InngestCommHandler.ts\";\n\n/**\n * Creates an {@link InngestCommHandler} that uses Web API `Request`/`Response`.\n *\n * This is shared by the edge and Node.js adapters so the handler logic isn't\n * duplicated.\n */\nexport const createWebApiCommHandler = (\n  frameworkName: SupportedFrameworkName,\n  options: RegisterOptions & { client: Inngest.Like },\n  syncOptions?: SyncHandlerOptions,\n): InngestCommHandler => {\n  return new InngestCommHandler({\n    frameworkName,\n    ...options,\n    syncOptions,\n    handler: (req: Request) => {\n      return {\n        body: () => req.text(),\n        headers: (key: string) => req.headers.get(key),\n        method: () => req.method,\n        url: () => new URL(req.url, `https://${req.headers.get(\"host\") || \"\"}`),\n        transformResponse: ({ body, status, headers }) => {\n          return new Response(body, { status, headers });\n        },\n        experimentalTransformSyncResponse: async (data) => {\n          const res = data as Response;\n\n          const headers: Record<string, string> = {};\n          res.headers.forEach((v, k) => {\n            headers[k] = v;\n          });\n\n          return {\n            headers,\n            status: res.status,\n            body: await res.clone().text(),\n          };\n        },\n      };\n    },\n  });\n};\n"],"mappings":";;;;;;;;;AAaA,MAAa,2BACX,eACA,SACA,gBACuB;AACvB,QAAO,IAAIA,8CAAmB;EAC5B;EACA,GAAG;EACH;EACA,UAAU,QAAiB;AACzB,UAAO;IACL,YAAY,IAAI,MAAM;IACtB,UAAU,QAAgB,IAAI,QAAQ,IAAI,IAAI;IAC9C,cAAc,IAAI;IAClB,WAAW,IAAI,IAAI,IAAI,KAAK,WAAW,IAAI,QAAQ,IAAI,OAAO,IAAI,KAAK;IACvE,oBAAoB,EAAE,MAAM,QAAQ,cAAc;AAChD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEhD,mCAAmC,OAAO,SAAS;KACjD,MAAM,MAAM;KAEZ,MAAMC,UAAkC,EAAE;AAC1C,SAAI,QAAQ,SAAS,GAAG,MAAM;AAC5B,cAAQ,KAAK;OACb;AAEF,YAAO;MACL;MACA,QAAQ,IAAI;MACZ,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM;MAC/B;;IAEJ;;EAEJ,CAAC"}

package/components/createWebApiCommHandler.js

@@ -0,0 +1,46 @@
+import { InngestCommHandler } from "./InngestCommHandler.js";
+
+//#region src/components/createWebApiCommHandler.ts
+/**
+* Creates an {@link InngestCommHandler} that uses Web API `Request`/`Response`.
+*
+* This is shared by the edge and Node.js adapters so the handler logic isn't
+* duplicated.
+*/
+const createWebApiCommHandler = (frameworkName, options, syncOptions) => {
+	return new InngestCommHandler({
+		frameworkName,
+		...options,
+		syncOptions,
+		handler: (req) => {
+			return {
+				body: () => req.text(),
+				headers: (key) => req.headers.get(key),
+				method: () => req.method,
+				url: () => new URL(req.url, `https://${req.headers.get("host") || ""}`),
+				transformResponse: ({ body, status, headers }) => {
+					return new Response(body, {
+						status,
+						headers
+					});
+				},
+				experimentalTransformSyncResponse: async (data) => {
+					const res = data;
+					const headers = {};
+					res.headers.forEach((v, k) => {
+						headers[k] = v;
+					});
+					return {
+						headers,
+						status: res.status,
+						body: await res.clone().text()
+					};
+				}
+			};
+		}
+	});
+};
+
+//#endregion
+export { createWebApiCommHandler };
+//# sourceMappingURL=createWebApiCommHandler.js.map

package/components/createWebApiCommHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWebApiCommHandler.js","names":["headers: Record<string, string>"],"sources":["../../src/components/createWebApiCommHandler.ts"],"sourcesContent":["import type { RegisterOptions, SupportedFrameworkName } from \"../types.ts\";\nimport type { Inngest } from \"./Inngest.ts\";\nimport {\n  InngestCommHandler,\n  type SyncHandlerOptions,\n} from \"./InngestCommHandler.ts\";\n\n/**\n * Creates an {@link InngestCommHandler} that uses Web API `Request`/`Response`.\n *\n * This is shared by the edge and Node.js adapters so the handler logic isn't\n * duplicated.\n */\nexport const createWebApiCommHandler = (\n  frameworkName: SupportedFrameworkName,\n  options: RegisterOptions & { client: Inngest.Like },\n  syncOptions?: SyncHandlerOptions,\n): InngestCommHandler => {\n  return new InngestCommHandler({\n    frameworkName,\n    ...options,\n    syncOptions,\n    handler: (req: Request) => {\n      return {\n        body: () => req.text(),\n        headers: (key: string) => req.headers.get(key),\n        method: () => req.method,\n        url: () => new URL(req.url, `https://${req.headers.get(\"host\") || \"\"}`),\n        transformResponse: ({ body, status, headers }) => {\n          return new Response(body, { status, headers });\n        },\n        experimentalTransformSyncResponse: async (data) => {\n          const res = data as Response;\n\n          const headers: Record<string, string> = {};\n          res.headers.forEach((v, k) => {\n            headers[k] = v;\n          });\n\n          return {\n            headers,\n            status: res.status,\n            body: await res.clone().text(),\n          };\n        },\n      };\n    },\n  });\n};\n"],"mappings":";;;;;;;;;AAaA,MAAa,2BACX,eACA,SACA,gBACuB;AACvB,QAAO,IAAI,mBAAmB;EAC5B;EACA,GAAG;EACH;EACA,UAAU,QAAiB;AACzB,UAAO;IACL,YAAY,IAAI,MAAM;IACtB,UAAU,QAAgB,IAAI,QAAQ,IAAI,IAAI;IAC9C,cAAc,IAAI;IAClB,WAAW,IAAI,IAAI,IAAI,KAAK,WAAW,IAAI,QAAQ,IAAI,OAAO,IAAI,KAAK;IACvE,oBAAoB,EAAE,MAAM,QAAQ,cAAc;AAChD,YAAO,IAAI,SAAS,MAAM;MAAE;MAAQ;MAAS,CAAC;;IAEhD,mCAAmC,OAAO,SAAS;KACjD,MAAM,MAAM;KAEZ,MAAMA,UAAkC,EAAE;AAC1C,SAAI,QAAQ,SAAS,GAAG,MAAM;AAC5B,cAAQ,KAAK;OACb;AAEF,YAAO;MACL;MACA,QAAQ,IAAI;MACZ,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM;MAC/B;;IAEJ;;EAEJ,CAAC"}

package/components/execution/InngestExecution.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.cjs","names":["ExecutionVersion","options: InngestExecutionOptions","debugPrefix"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\">;\n  stepState: Record<string, MemoizedOp>;\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  isFailureHandler?: boolean;\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACXA,gCAAiB;AA0EnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUC,SAAkC;EAAlC;AACpB,OAAK,8BAAiB,GAAGC,2BAAY,GAAG,KAAK,QAAQ,QAAQ"}
+{"version":3,"file":"InngestExecution.cjs","names":["ExecutionVersion","options: InngestExecutionOptions","debugPrefix"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\">;\n  stepState: Record<string, MemoizedOp>;\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  isFailureHandler?: boolean;\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,\n   * the execution engine may deliver the result as an SSE stream even if\n   * `stream.push()` was not called.\n   */\n  acceptsSse?: boolean;\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACXA,gCAAiB;AAiFnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUC,SAAkC;EAAlC;AACpB,OAAK,8BAAiB,GAAGC,2BAAY,GAAG,KAAK,QAAQ,QAAQ"}

package/components/execution/InngestExecution.d.cts

@@ -124,6 +124,12 @@ interface InngestExecutionOptions {
    * client. This ensures `wrapRequest` and other hooks share state on `this`.
    */
   middlewareInstances?: Middleware.BaseMiddleware[];
+  /**
+   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,
+   * the execution engine may deliver the result as an SSE stream even if
+   * `stream.push()` was not called.
+   */
+  acceptsSse?: boolean;
   /**
    * Provide the ability to transform the context passed to the function before
    * the execution starts.

package/components/execution/InngestExecution.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.d.cts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAiBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EArDd,IAqDc,CArDT,OAAA,CAAQ,GAqDC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EAtDA,MAsDA,CAAA,MAAgB,EAtDD,UAsDC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EAvDrB,QAuDqB;qBAFX,CAAA,EApDE,4BAoDF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EAvDD,MAuDC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UArDR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;uBAMZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}
+{"version":3,"file":"InngestExecution.d.cts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAwBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EA5Dd,IA4Dc,CA5DT,OAAA,CAAQ,GA4DC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EA7DA,MA6DA,CAAA,MAAgB,EA7DD,UA6DC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EA9DrB,QA8DqB;qBAFX,CAAA,EA3DE,4BA2DF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EA9DD,MA8DC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UA5DR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}

package/components/execution/InngestExecution.d.ts

@@ -124,6 +124,12 @@ interface InngestExecutionOptions {
    * client. This ensures `wrapRequest` and other hooks share state on `this`.
    */
   middlewareInstances?: Middleware.BaseMiddleware[];
+  /**
+   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,
+   * the execution engine may deliver the result as an SSE stream even if
+   * `stream.push()` was not called.
+   */
+  acceptsSse?: boolean;
   /**
    * Provide the ability to transform the context passed to the function before
    * the execution starts.

package/components/execution/InngestExecution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.d.ts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAiBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EArDd,IAqDc,CArDT,OAAA,CAAQ,GAqDC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EAtDA,MAsDA,CAAA,MAAgB,EAtDD,UAsDC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EAvDrB,QAuDqB;qBAFX,CAAA,EApDE,4BAoDF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EAvDD,MAuDC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UArDR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;uBAMZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}
+{"version":3,"file":"InngestExecution.d.ts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAwBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EA5Dd,IA4Dc,CA5DT,OAAA,CAAQ,GA4DC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EA7DA,MA6DA,CAAA,MAAgB,EA7DD,UA6DC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EA9DrB,QA8DqB;qBAFX,CAAA,EA3DE,4BA2DF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EA9DD,MA8DC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UA5DR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}

package/components/execution/InngestExecution.js.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.js","names":["options: InngestExecutionOptions"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\">;\n  stepState: Record<string, MemoizedOp>;\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  isFailureHandler?: boolean;\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACX,iBAAiB;AA0EnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUA,SAAkC;EAAlC;AACpB,OAAK,WAAW,MAAM,GAAG,YAAY,GAAG,KAAK,QAAQ,QAAQ"}
+{"version":3,"file":"InngestExecution.js","names":["options: InngestExecutionOptions"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\">;\n  stepState: Record<string, MemoizedOp>;\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  isFailureHandler?: boolean;\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,\n   * the execution engine may deliver the result as an SSE stream even if\n   * `stream.push()` was not called.\n   */\n  acceptsSse?: boolean;\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACX,iBAAiB;AAiFnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUA,SAAkC;EAAlC;AACpB,OAAK,WAAW,MAAM,GAAG,YAAY,GAAG,KAAK,QAAQ,QAAQ"}

package/components/execution/als.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"als.cjs","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions;\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;;AA4EA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}
+{"version":3,"file":"als.cjs","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & { hashedId?: string };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;;AAmFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}

package/components/execution/als.d.cts

@@ -1,3 +1,4 @@
+import { Stream } from "../StreamTools.cjs";
 import { IInngestExecution } from "./InngestExecution.cjs";
 import { Context, StepOptions } from "../../types.cjs";
 import { Inngest } from "../Inngest.cjs";
@@ -34,12 +35,19 @@ interface AsyncContext {
      * callback. Useful to understand whether we are in the context of a step
      * execution or within the main function body.
      */
-    executingStep?: StepOptions;
+    executingStep?: StepOptions & {
+      hashedId?: string;
+    };
     /**
      * If present, indicates the parallel mode that should be applied to steps
      * created within this context. Set by `group.parallel()`.
      */
     parallelMode?: "race";
+    /**
+     * The stream tools instance for this execution context. Used by the
+     * `stream` singleton to push/pipe SSE data to the client.
+     */
+    stream?: Stream;
     /**
      * If present, indicates the variant callback is executing within an
      * experiment. Set by `group.experiment()`. Any `step.*()` call within

package/components/execution/als.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"als.d.cts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAOA;AAA6B,UAAZ,YAAA,CAAY;;;;;;AA4I7B;EAEC,GAAA,EAvIM,OAAA,CAAQ,IAuId;;;;;;;;;cA7Ha;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8GP,mBAAwB,QAAQ"}
+{"version":3,"file":"als.d.cts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAkJhB,GAAA,EA3IN,OAAA,CAAQ,IA6Id;EAAA;;;;;;;;cAnIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;aAYP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwGA,mBAAwB,QAAQ"}

package/components/execution/als.d.ts

@@ -1,3 +1,4 @@
+import { Stream } from "../StreamTools.js";
 import { IInngestExecution } from "./InngestExecution.js";
 import { Context, StepOptions } from "../../types.js";
 import { Inngest } from "../Inngest.js";
@@ -34,12 +35,19 @@ interface AsyncContext {
      * callback. Useful to understand whether we are in the context of a step
      * execution or within the main function body.
      */
-    executingStep?: StepOptions;
+    executingStep?: StepOptions & {
+      hashedId?: string;
+    };
     /**
      * If present, indicates the parallel mode that should be applied to steps
      * created within this context. Set by `group.parallel()`.
      */
     parallelMode?: "race";
+    /**
+     * The stream tools instance for this execution context. Used by the
+     * `stream` singleton to push/pipe SSE data to the client.
+     */
+    stream?: Stream;
     /**
      * If present, indicates the variant callback is executing within an
      * experiment. Set by `group.experiment()`. Any `step.*()` call within

package/components/execution/als.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"als.d.ts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAOA;AAA6B,UAAZ,YAAA,CAAY;;;;;;AA4I7B;EAEC,GAAA,EAvIM,OAAA,CAAQ,IAuId;;;;;;;;;cA7Ha;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8GP,mBAAwB,QAAQ"}
+{"version":3,"file":"als.d.ts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAkJhB,GAAA,EA3IN,OAAA,CAAQ,IA6Id;EAAA;;;;;;;;cAnIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;aAYP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwGA,mBAAwB,QAAQ"}

package/components/execution/als.js.map

@@ -1 +1 @@
-{"version":3,"file":"als.js","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions;\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;AA4EA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}
+{"version":3,"file":"als.js","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & { hashedId?: string };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;AAmFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}