effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/internal/protocol.js

@@ -1,20 +1,13 @@
-import { Predicate, Struct } from "effect";
-import * as Schema$1 from "effect/Schema";
-
+import { Effect, Predicate, Schema, SchemaTransformation, Struct } from "effect";
 //#region src/internal/protocol.ts
-/**
-* Wire protocol schemas and opcode factories for Inngest communication.
-* @internal
-*/
 const stripTopLevelTag = (value) => {
-	if (Predicate.isRecord(value)) return Struct.omit(value, "_tag");
+	if (Predicate.isObject(value)) return Struct.omit(value, ["_tag"]);
 	return value;
 };
-const WireUnknown = Schema$1.transform(Schema$1.Unknown, Schema$1.Unknown, {
-	strict: true,
+const WireUnknown = Schema.Unknown.pipe(Schema.decodeTo(Schema.Unknown, SchemaTransformation.transform({
 	decode: (value) => value,
 	encode: (value) => stripTopLevelTag(value)
-});
+})));
 const Opcode = {
 	None: "None",
 	Step: "Step",
@@ -32,64 +25,60 @@ const Opcode = {
 	SyncRunComplete: "SyncRunComplete",
 	DiscoveryRequest: "DiscoveryRequest"
 };
-var UserError = class extends Schema$1.Class("UserError")({
-	name: Schema$1.String,
-	message: Schema$1.String,
-	stack: Schema$1.optional(Schema$1.String),
-	data: Schema$1.optional(Schema$1.Unknown),
-	noRetry: Schema$1.optional(Schema$1.Boolean),
-	cause: Schema$1.optional(Schema$1.Unknown)
-}) {};
-const StepResult = Schema$1.NullOr(Schema$1.Record({
-	key: Schema$1.String,
-	value: Schema$1.Unknown
-}).pipe(Schema$1.annotations({ identifier: "StepResultObject" })));
-var FunctionStack = class extends Schema$1.Class("FunctionStack")({
-	stack: Schema$1.Array(Schema$1.String),
-	current: Schema$1.Number
+const RUN_COMPLETE_ID = "0737c22d3bfae812339732d14d8c7dbd6dc4e09c";
+var UserError = class UserError extends Schema.Class("UserError")({
+	name: Schema.String,
+	message: Schema.String,
+	stack: Schema.optional(Schema.String),
+	data: Schema.optional(Schema.Unknown),
+	noRetry: Schema.optional(Schema.Boolean),
+	cause: Schema.optional(Schema.Unknown)
+}) {
+	static fromUnknown(error) {
+		return UserError.make({
+			name: Predicate.hasProperty(error, "name") ? String(error.name) : "Error",
+			message: Predicate.hasProperty(error, "message") ? String(error.message) : String(error),
+			stack: Predicate.hasProperty(error, "stack") ? String(error.stack) : void 0
+		});
+	}
+};
+const StepResult = Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.annotate({ identifier: "StepResultObject" })));
+var FunctionStack = class extends Schema.Class("FunctionStack")({
+	stack: Schema.Array(Schema.String),
+	current: Schema.Number
 }) {};
-var InngestEvent = class extends Schema$1.Class("InngestEvent")({
-	id: Schema$1.optional(Schema$1.String),
-	name: Schema$1.String,
-	data: Schema$1.optionalWith(Schema$1.Record({
-		key: Schema$1.String,
-		value: Schema$1.Unknown
-	}), {
-		default: () => ({}),
-		nullable: true
-	}),
-	ts: Schema$1.optional(Schema$1.Number),
-	user: Schema$1.optional(Schema$1.Record({
-		key: Schema$1.String,
-		value: Schema$1.Unknown
-	})),
-	v: Schema$1.optional(Schema$1.String)
+var InngestEvent = class extends Schema.Class("InngestEvent")({
+	id: Schema.optional(Schema.String),
+	name: Schema.String,
+	data: Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown)).pipe(Schema.withDecodingDefaultType(Effect.succeed({}))),
+	ts: Schema.optional(Schema.Number),
+	user: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	v: Schema.optional(Schema.String)
 }) {};
-var SDKRequestContext = class extends Schema$1.Class("SDKRequestContext")({
-	fn_id: Schema$1.String,
-	run_id: Schema$1.String,
-	env: Schema$1.optionalWith(Schema$1.String, { default: () => "dev" }),
-	step_id: Schema$1.optionalWith(Schema$1.String, { default: () => "step" }),
-	attempt: Schema$1.optionalWith(Schema$1.Number, { default: () => 0 }),
-	max_attempts: Schema$1.optionalWith(Schema$1.Number, { default: () => 4 }),
-	stack: Schema$1.optionalWith(FunctionStack, { default: () => FunctionStack.make({
+var SDKRequestContext = class extends Schema.Class("SDKRequestContext")({
+	fn_id: Schema.String,
+	run_id: Schema.String,
+	env: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("dev"))),
+	step_id: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("step"))),
+	attempt: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+	max_attempts: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(4))),
+	stack: FunctionStack.pipe(Schema.withDecodingDefaultType(Effect.succeed(FunctionStack.make({
 		stack: [],
 		current: 0
-	}) }),
-	qi_id: Schema$1.optionalWith(Schema$1.String, { default: () => "" }),
-	disable_immediate_execution: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false }),
-	use_api: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false })
+	})))),
+	qi_id: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+	request_id: Schema.optionalKey(Schema.String),
+	generation_id: Schema.optionalKey(Schema.Number),
+	disable_immediate_execution: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+	use_api: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false)))
 }) {};
-var SDKRequestBody = class extends Schema$1.Class("SDKRequestBody")({
+var SDKRequestBody = class extends Schema.Class("SDKRequestBody")({
 	event: InngestEvent,
-	events: Schema$1.Array(InngestEvent),
-	steps: Schema$1.optionalWith(Schema$1.Record({
-		key: Schema$1.String,
-		value: StepResult
-	}), { default: () => ({}) }),
+	events: Schema.Array(InngestEvent),
+	steps: Schema.Record(Schema.String, StepResult).pipe(Schema.withDecodingDefault(Effect.succeed({}))),
 	ctx: SDKRequestContext,
-	version: Schema$1.optionalWith(Schema$1.Number, { default: () => 1 }),
-	use_api: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false })
+	version: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(1))),
+	use_api: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false)))
 }) {};
 const Headers = {
 	SDK: "X-Inngest-SDK",
@@ -97,6 +86,8 @@ const Headers = {
 	RequestVersion: "x-inngest-req-version",
 	NoRetry: "X-Inngest-No-Retry",
 	RetryAfter: "Retry-After",
+	SDKHandled: "x-inngest-sdk-handled",
+	SyncKind: "x-inngest-sync-kind",
 	ServerKind: "X-Inngest-Server-Kind",
 	ExpectedServerKind: "X-Inngest-Expected-Server-Kind",
 	RunID: "X-Run-ID",
@@ -104,84 +95,288 @@ const Headers = {
 	Platform: "X-Inngest-Platform",
 	Env: "X-Inngest-Env"
 };
-var GeneratorOpcode = class extends Schema$1.Class("GeneratorOpcode")({
-	op: Schema$1.Literal(Opcode.None, Opcode.Step, Opcode.StepRun, Opcode.StepError, Opcode.StepPlanned, Opcode.Sleep, Opcode.WaitForEvent, Opcode.InvokeFunction, Opcode.AIGateway, Opcode.Gateway, Opcode.WaitForSignal, Opcode.RunComplete, Opcode.StepFailed, Opcode.SyncRunComplete, Opcode.DiscoveryRequest),
-	id: Schema$1.String,
-	name: Schema$1.String,
-	mode: Schema$1.optional(Schema$1.Literal("sync", "async")),
-	opts: Schema$1.optional(WireUnknown),
-	data: Schema$1.optional(WireUnknown),
-	error: Schema$1.optional(UserError),
-	displayName: Schema$1.optional(Schema$1.String),
-	userland: Schema$1.optional(Schema$1.Struct({ id: Schema$1.String }))
-}) {};
-const mkOpcode = (info, op, extra) => GeneratorOpcode.make({
-	op,
-	id: info.hash,
-	name: info.id,
-	displayName: info.name,
-	...extra
-});
-const stepPlanned = (info) => mkOpcode(info, Opcode.StepPlanned);
-const stepRun = (info, data) => mkOpcode(info, Opcode.StepRun, { data });
-const stepError = (info, error, noRetry) => {
-	const errorWithNoRetry = noRetry !== void 0 ? UserError.make({
-		name: error.name,
-		message: error.message,
-		stack: error.stack,
-		noRetry
-	}) : error;
-	return mkOpcode(info, Opcode.StepError, { error: errorWithNoRetry });
-};
-const sleep = (info, duration) => GeneratorOpcode.make({
-	op: Opcode.Sleep,
-	id: info.hash,
-	name: duration,
-	displayName: info.name,
-	mode: "async"
-});
-const waitForEvent = (info, opts) => mkOpcode(info, Opcode.WaitForEvent, {
-	mode: "async",
-	opts
-});
-const invokeFunction = (info, opts) => mkOpcode(info, Opcode.InvokeFunction, {
-	mode: "async",
-	opts,
-	userland: { id: info.id }
-});
-const IntrospectionBase = Schema$1.Struct({
-	function_count: Schema$1.Number,
-	has_event_key: Schema$1.Boolean,
-	has_signing_key: Schema$1.Boolean,
-	has_signing_key_fallback: Schema$1.Boolean,
-	mode: Schema$1.Literal("cloud", "dev"),
-	schema_version: Schema$1.Literal("2024-05-24"),
-	extra: Schema$1.optional(Schema$1.Record({
-		key: Schema$1.String,
-		value: Schema$1.Unknown
+var GeneratorOpcode = class GeneratorOpcode extends Schema.Class("GeneratorOpcode")({
+	op: Schema.Literals([
+		Opcode.None,
+		Opcode.Step,
+		Opcode.StepRun,
+		Opcode.StepError,
+		Opcode.StepPlanned,
+		Opcode.Sleep,
+		Opcode.WaitForEvent,
+		Opcode.InvokeFunction,
+		Opcode.AIGateway,
+		Opcode.Gateway,
+		Opcode.WaitForSignal,
+		Opcode.RunComplete,
+		Opcode.StepFailed,
+		Opcode.SyncRunComplete,
+		Opcode.DiscoveryRequest
+	]),
+	id: Schema.String,
+	name: Schema.optional(Schema.String),
+	mode: Schema.optional(Schema.Literals(["sync", "async"])),
+	opts: Schema.optional(WireUnknown),
+	data: Schema.optional(WireUnknown),
+	error: Schema.optional(UserError),
+	displayName: Schema.optional(Schema.String),
+	userland: Schema.optional(Schema.Struct({ id: Schema.String })),
+	timing: Schema.optional(Schema.Struct({
+		a: Schema.Number,
+		b: Schema.Number
 	}))
+}) {
+	static makeStep(args) {
+		return GeneratorOpcode.make({
+			op: args.op,
+			id: args.info.hash,
+			name: args.info.id,
+			displayName: args.info.name,
+			...args.extra
+		});
+	}
+	static stepPlanned(info) {
+		return GeneratorOpcode.makeStep({
+			info,
+			op: Opcode.StepPlanned,
+			extra: {
+				opts: {},
+				userland: { id: info.id },
+				data: null
+			}
+		});
+	}
+	static sendEventStepPlanned(info) {
+		return GeneratorOpcode.makeStep({
+			info,
+			op: Opcode.StepPlanned,
+			extra: {
+				name: "sendEvent",
+				opts: { type: "step.sendEvent" },
+				userland: { id: info.id },
+				data: null
+			}
+		});
+	}
+	static stepRun(args) {
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepRun,
+			extra: {
+				mode: "sync",
+				opts: {},
+				userland: { id: args.info.id },
+				rawArgs: [args.info.rawStepArg ?? args.info.id, null],
+				hashedId: args.info.hash,
+				fulfilled: true,
+				hasStepState: true,
+				handled: true,
+				promise: {},
+				middleware: { stepInfo: {
+					hashedId: args.info.hash,
+					memoized: false,
+					options: {
+						id: args.info.id,
+						name: args.info.name
+					},
+					stepType: "run"
+				} },
+				memoizationDeferred: { promise: {} },
+				transformedResultPromise: {},
+				...Predicate.isNotUndefined(args.data) ? { data: args.data } : {},
+				timing: {
+					a: Date.now() * 1e6,
+					b: 0
+				}
+			}
+		});
+	}
+	static sendEventStepRun(args) {
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepRun,
+			extra: {
+				name: "sendEvent",
+				mode: "sync",
+				userland: { id: args.info.id },
+				opts: { type: "step.sendEvent" },
+				rawArgs: [args.info.id, args.rawPayload],
+				hashedId: args.info.hash,
+				promise: {},
+				fulfilled: true,
+				hasStepState: true,
+				handled: true,
+				middleware: { stepInfo: {
+					hashedId: args.info.hash,
+					memoized: false,
+					options: {
+						id: args.info.id,
+						name: args.info.name
+					},
+					stepType: "sendEvent"
+				} },
+				memoizationDeferred: { promise: {} },
+				transformedResultPromise: {},
+				data: args.data,
+				timing: {
+					a: Date.now() * 1e6,
+					b: 0
+				}
+			}
+		});
+	}
+	static stepRunResponse(args) {
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepRun,
+			extra: {
+				opts: {},
+				userland: { id: args.info.id },
+				...Predicate.isNotUndefined(args.data) ? { data: args.data } : {},
+				timing: {
+					a: Date.now() * 1e6,
+					b: 0
+				}
+			}
+		});
+	}
+	static sendEventStepRunResponse(args) {
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepRun,
+			extra: {
+				name: "sendEvent",
+				opts: { type: "step.sendEvent" },
+				userland: { id: args.info.id },
+				data: args.data,
+				timing: {
+					a: Date.now() * 1e6,
+					b: 0
+				}
+			}
+		});
+	}
+	static stepError(args) {
+		const error = Predicate.isNotUndefined(args.noRetry) ? UserError.make({
+			name: args.error.name,
+			message: args.error.message,
+			stack: args.error.stack,
+			noRetry: args.noRetry
+		}) : args.error;
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepError,
+			extra: { error }
+		});
+	}
+	static stepFailed(args) {
+		return GeneratorOpcode.makeStep({
+			info: args.info,
+			op: Opcode.StepFailed,
+			extra: {
+				opts: {},
+				userland: { id: args.info.id },
+				error: args.error,
+				data: {
+					__serialized: true,
+					name: args.error.name,
+					message: args.error.message,
+					stack: ""
+				}
+			}
+		});
+	}
+	static sleep(args) {
+		return GeneratorOpcode.make({
+			op: Opcode.Sleep,
+			id: args.info.hash,
+			name: args.duration,
+			displayName: args.info.name,
+			opts: {},
+			userland: { id: args.info.id },
+			data: null
+		});
+	}
+	static waitForEvent(args) {
+		return GeneratorOpcode.make({
+			op: Opcode.WaitForEvent,
+			id: args.info.hash,
+			name: args.event,
+			displayName: args.info.name,
+			opts: {
+				timeout: args.timeout,
+				...Predicate.isNotUndefined(args.if) ? { if: args.if } : {}
+			},
+			userland: { id: args.info.id },
+			data: null
+		});
+	}
+	static invokeFunction(args) {
+		return GeneratorOpcode.make({
+			op: Opcode.InvokeFunction,
+			id: args.info.hash,
+			displayName: args.info.name,
+			opts: {
+				payload: args.payload,
+				function_id: args.functionId,
+				...Predicate.isNotUndefined(args.timeout) ? { timeout: args.timeout } : {}
+			},
+			userland: { id: args.info.id },
+			data: null
+		});
+	}
+	static runComplete(data) {
+		return GeneratorOpcode.make({
+			op: Opcode.RunComplete,
+			id: RUN_COMPLETE_ID,
+			data
+		});
+	}
+	static discoveryRequest() {
+		return GeneratorOpcode.make({
+			op: Opcode.DiscoveryRequest,
+			id: "step",
+			name: "step"
+		});
+	}
+};
+const IntrospectionBase = Schema.Struct({
+	function_count: Schema.Number,
+	has_event_key: Schema.Boolean,
+	has_signing_key: Schema.Boolean,
+	has_signing_key_fallback: Schema.optional(Schema.Boolean),
+	mode: Schema.Literals(["cloud", "dev"]),
+	schema_version: Schema.Literal("2024-05-24"),
+	extra: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
 });
-const IntrospectionUnauthenticated = Schema$1.extend(IntrospectionBase, Schema$1.Struct({
-	authentication_succeeded: Schema$1.Union(Schema$1.Literal(false), Schema$1.Null),
-	functions: Schema$1.optionalWith(Schema$1.Array(Schema$1.Unknown), { exact: true })
+const IntrospectionUnauthenticated = IntrospectionBase.pipe(Schema.fieldsAssign({
+	authentication_succeeded: Schema.optional(Schema.Union([Schema.Literal(false), Schema.Null])),
+	capabilities: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	functions: Schema.optionalKey(Schema.Array(Schema.Unknown))
 }));
-const IntrospectionAuthenticated = Schema$1.extend(IntrospectionBase, Schema$1.Struct({
-	authentication_succeeded: Schema$1.Literal(true),
-	api_origin: Schema$1.String,
-	app_id: Schema$1.String,
-	env: Schema$1.NullOr(Schema$1.String),
-	event_api_origin: Schema$1.String,
-	event_key_hash: Schema$1.NullOr(Schema$1.String),
-	framework: Schema$1.String,
-	sdk_language: Schema$1.String,
-	sdk_version: Schema$1.String,
-	serve_origin: Schema$1.NullOr(Schema$1.String),
-	serve_path: Schema$1.NullOr(Schema$1.String),
-	signing_key_fallback_hash: Schema$1.NullOr(Schema$1.String),
-	signing_key_hash: Schema$1.NullOr(Schema$1.String)
+const IntrospectionAuthenticated = IntrospectionBase.pipe(Schema.fieldsAssign({
+	authentication_succeeded: Schema.Literal(true),
+	api_origin: Schema.String,
+	app_id: Schema.String,
+	env: Schema.NullOr(Schema.String),
+	event_api_origin: Schema.String,
+	event_key_hash: Schema.NullOr(Schema.String),
+	framework: Schema.String,
+	sdk_language: Schema.String,
+	sdk_version: Schema.String,
+	serve_origin: Schema.NullOr(Schema.String),
+	serve_path: Schema.NullOr(Schema.String),
+	signing_key_fallback_hash: Schema.NullOr(Schema.String),
+	signing_key_hash: Schema.NullOr(Schema.String)
 }));
-const IntrospectionResponse = Schema$1.Union(IntrospectionAuthenticated, IntrospectionUnauthenticated);
-const RegisterResponse = Schema$1.Struct({ message: Schema$1.optional(Schema$1.String) });
-
+const IntrospectionResponse = Schema.Union([IntrospectionAuthenticated, IntrospectionUnauthenticated]);
+const RegisterResponse = Schema.Struct({
+	message: Schema.String,
+	modified: Schema.Boolean
+});
+const RegisterServerResponse = Schema.Union([Schema.Struct({
+	ok: Schema.Literal(true),
+	modified: Schema.optional(Schema.Boolean)
+}), Schema.Struct({ error: Schema.optional(Schema.String) })]);
 //#endregion
-export { GeneratorOpcode, Headers, IntrospectionResponse, Opcode, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError, invokeFunction, sleep, stepError, stepPlanned, stepRun, waitForEvent };
+export { GeneratorOpcode, Headers, IntrospectionResponse, RegisterResponse, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError };

package/dist/internal/runtime/CheckpointContext.js

@@ -0,0 +1,5 @@
+import { Context, Option } from "effect";
+//#region src/internal/runtime/CheckpointContext.ts
+const CurrentCheckpoint = Context.Reference("effect-inngest/internal/runtime/CurrentCheckpoint", { defaultValue: Option.none });
+//#endregion
+export { CurrentCheckpoint };

package/dist/internal/runtime/HandlerContext.d.ts

@@ -0,0 +1,13 @@
+import { InngestFunction } from "../../Function.js";
+import { ExecutionInput } from "../domain/ExecutionInput.js";
+import { StepTools } from "./StepTools.js";
+import { Effect } from "effect";
+
+//#region src/internal/runtime/HandlerContext.d.ts
+interface HandlerContext<F extends InngestFunction.Any = InngestFunction.Any> {
+  readonly event: InngestFunction.EventType<F>;
+  readonly step: StepTools.Service;
+  readonly run: ExecutionInput["run"];
+}
+//#endregion
+export { HandlerContext };

package/dist/internal/runtime/HandlerContext.js

@@ -0,0 +1,19 @@
+import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
+import { decodeInvocation } from "../codec/EventPayload.js";
+import { StepTools } from "./StepTools.js";
+import { Effect } from "effect";
+//#region src/internal/runtime/HandlerContext.ts
+const make = (args) => Effect.gen(function* () {
+	const input = yield* CurrentExecutionInput;
+	const step = yield* StepTools;
+	return {
+		event: yield* decodeInvocation({
+			fn: args.fn,
+			input
+		}),
+		step,
+		run: input.run
+	};
+});
+//#endregion
+export { make };

package/dist/internal/runtime/HandlerFiberScope.d.ts

@@ -0,0 +1,10 @@
+import { Context, Effect } from "effect";
+
+//#region src/internal/runtime/HandlerFiberScope.d.ts
+interface Service {
+  readonly isForkedFromHandlerRoot: Effect.Effect<boolean>;
+}
+declare const HandlerFiberScope_base: Context.ServiceClass<HandlerFiberScope, "effect-inngest/internal/runtime/HandlerFiberScope", Service>;
+declare class HandlerFiberScope extends HandlerFiberScope_base {}
+//#endregion
+export { HandlerFiberScope };

package/dist/internal/runtime/HandlerFiberScope.js

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+//#region src/internal/runtime/HandlerFiberScope.ts
+var HandlerFiberScope = class extends Context.Service()("effect-inngest/internal/runtime/HandlerFiberScope") {};
+//#endregion
+export { HandlerFiberScope };

package/dist/internal/runtime/StepCommandBus.d.ts

@@ -0,0 +1,27 @@
+import { ErrorCommand, PlanCommand, ResultCommand, YieldCommand } from "../domain/StepCommand.js";
+import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
+import { HandlerFiberScope } from "./HandlerFiberScope.js";
+import { ExecutionSuspension, GeneratorOpcode } from "../domain/ExecutionSuspension.js";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/internal/runtime/StepCommandBus.d.ts
+declare namespace StepCommandBus {
+  interface Service {
+    readonly suspend: (command: YieldCommand) => Effect.Effect<void>;
+    readonly complete: (command: ResultCommand) => Effect.Effect<void>;
+    readonly plan: (command: PlanCommand) => Effect.Effect<void>;
+    readonly planCheckpointedFork: (command: PlanCommand) => Effect.Effect<boolean, never, CurrentExecutionInput | HandlerFiberScope>;
+    readonly planCheckpointedRunBoundary: (command: PlanCommand) => Effect.Effect<boolean, never, CurrentExecutionInput | HandlerFiberScope>;
+    readonly fail: (command: ErrorCommand) => Effect.Effect<void>;
+    readonly takePlanned: () => Effect.Effect<ReadonlyArray<GeneratorOpcode>>;
+    readonly takeCompleted: () => Effect.Effect<ReadonlyArray<GeneratorOpcode>>;
+    readonly takeSuspension: () => Effect.Effect<ExecutionSuspension>;
+  }
+}
+declare const StepCommandBus_base: Context.ServiceClass<StepCommandBus, "effect-inngest/internal/runtime/StepCommandBus", StepCommandBus.Service>;
+declare class StepCommandBus extends StepCommandBus_base {
+  static readonly make: Effect.Effect<StepCommandBus.Service, never, never>;
+  static readonly layer: Layer.Layer<StepCommandBus, never, never>;
+}
+//#endregion
+export { StepCommandBus };

package/dist/internal/runtime/StepCommandBus.js

@@ -0,0 +1,76 @@
+import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
+import { CurrentCheckpoint } from "./CheckpointContext.js";
+import { HandlerFiberScope } from "./HandlerFiberScope.js";
+import { ExecutionSuspension, SuspendedCommand } from "../domain/ExecutionSuspension.js";
+import { checkpoint, completion, failure, plan } from "../domain/StepCommand.js";
+import { Array, Context, Effect, Layer, Option, Ref } from "effect";
+//#region src/internal/runtime/StepCommandBus.ts
+const plannedFromCheckpoint = CurrentCheckpoint.pipe(Effect.flatMap(Option.match({
+	onNone: () => Effect.succeed(Array.empty()),
+	onSome: (state) => state.takePlanned()
+})));
+const completedFromCheckpoint = CurrentCheckpoint.pipe(Effect.flatMap(Option.match({
+	onNone: () => Effect.succeed(Array.empty()),
+	onSome: (state) => state.takeCompleted()
+})));
+var StepCommandBus = class StepCommandBus extends Context.Service()("effect-inngest/internal/runtime/StepCommandBus") {
+	static make = Effect.gen(function* () {
+		const suspended = yield* Ref.make(Array.empty());
+		const suspendExecution = (command) => Ref.update(suspended, Array.append(command)).pipe(Effect.andThen(Effect.interrupt));
+		const takeSuspended = Ref.modify(suspended, (current) => [current, Array.empty()]);
+		const takeSuspension = () => Effect.gen(function* () {
+			const completed = yield* completedFromCheckpoint;
+			const commands = yield* takeSuspended;
+			return ExecutionSuspension.from({
+				completed,
+				suspended: commands
+			});
+		});
+		const plan$1 = (command) => Effect.gen(function* () {
+			const checkpoint = yield* CurrentCheckpoint;
+			const planned = plan(command);
+			if (Option.isNone(checkpoint)) return yield* suspendExecution(SuspendedCommand.fromPlanned(planned));
+			return yield* checkpoint.value.plan(planned);
+		});
+		const planCheckpointedFork = (command) => Effect.gen(function* () {
+			const input = yield* CurrentExecutionInput;
+			const checkpoint = yield* CurrentCheckpoint;
+			const isForkedFromHandlerRoot = yield* (yield* HandlerFiberScope).isForkedFromHandlerRoot;
+			if (!input.isFunctionRun() || Option.isNone(checkpoint) || !isForkedFromHandlerRoot) return false;
+			yield* plan$1(command);
+			return true;
+		});
+		const planCheckpointedRunBoundary = (command) => Effect.gen(function* () {
+			const input = yield* CurrentExecutionInput;
+			const checkpoint = yield* CurrentCheckpoint;
+			if (input.isFunctionRun() && Option.isSome(checkpoint) && (yield* checkpoint.value.isRuntimeExceeded)) {
+				yield* checkpoint.value.flush;
+				yield* plan$1(command);
+				return yield* Effect.interrupt;
+			}
+			return yield* planCheckpointedFork(command);
+		});
+		return StepCommandBus.of({
+			suspend: (command) => Effect.gen(function* () {
+				const checkpoint = yield* CurrentCheckpoint;
+				if (Option.isSome(checkpoint)) yield* checkpoint.value.flush;
+				return yield* suspendExecution(SuspendedCommand.fromPlanned(plan(command)));
+			}),
+			complete: (command) => Effect.gen(function* () {
+				const checkpoint$1 = yield* CurrentCheckpoint;
+				if (Option.isNone(checkpoint$1)) return yield* suspendExecution(SuspendedCommand.fromOpcode(completion(command)));
+				return yield* checkpoint$1.value.record(checkpoint(command));
+			}),
+			plan: plan$1,
+			planCheckpointedFork,
+			planCheckpointedRunBoundary,
+			fail: (command) => suspendExecution(SuspendedCommand.fromFailure(failure(command))),
+			takePlanned: () => plannedFromCheckpoint,
+			takeCompleted: () => completedFromCheckpoint,
+			takeSuspension
+		});
+	});
+	static layer = Layer.effect(this, this.make);
+};
+//#endregion
+export { StepCommandBus };