effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/internal/codec/StepResult.js

@@ -0,0 +1,55 @@
+import { StepError } from "../errors.js";
+import { Effect, Function, Option, Predicate, Schema } from "effect";
+//#region src/internal/codec/StepResult.ts
+const messageFromCause = (cause) => {
+	if (Predicate.hasProperty(cause, "cause")) {
+		const nested = messageFromCause(cause.cause);
+		if (nested.length > 0) return nested;
+	}
+	const message = Predicate.hasProperty(cause, "message") ? String(cause.message) : "";
+	if (message.length > 0) return message;
+	const rendered = String(cause);
+	return rendered.length > 0 ? rendered : "Step result schema decode failed";
+};
+const memoDecodeError = (args) => StepError.make({
+	stepId: args.stepId,
+	message: messageFromCause(args.cause),
+	noRetry: true,
+	cause: args.cause
+});
+const failMemoDecode = (stepId, cause) => Effect.fail(memoDecodeError({
+	stepId,
+	cause
+}));
+const mapMemoDecodeError = Function.dual(2, (effect, stepId) => effect.pipe(Effect.mapError((cause) => memoDecodeError({
+	stepId,
+	cause
+}))));
+const decodeMemo = Function.dual(3, (value, schema, stepId) => Schema.decodeUnknownEffect(schema)(value).pipe(mapMemoDecodeError(stepId)));
+const encodeMemo = Function.dual(3, (value, schema, stepId) => Schema.encodeUnknownEffect(Schema.toCodecJson(schema))(value).pipe(mapMemoDecodeError(stepId)));
+const decodeStepRunMemo = (schema, stepId) => (value) => Option.match(schema, {
+	onNone: () => Effect.void,
+	onSome: (codec) => decodeMemo(codec, stepId)(value)
+});
+const encodeStepRunMemo = (schema, stepId) => (value) => Option.match(schema, {
+	onNone: () => Predicate.isUndefined(value) ? Effect.succeed(void 0) : decodeMemo(Schema.Json, stepId)(value),
+	onSome: (codec) => encodeMemo(codec, stepId)(value)
+});
+const failStepRunMemoError = (stepId, error) => Effect.fail(StepError.make({
+	stepId,
+	message: Predicate.hasProperty(error, "message") ? String(error.message) : "Step failed",
+	noRetry: true,
+	cause: error
+}));
+const failStepRunMemoTimeout = (stepId) => Effect.fail(StepError.make({
+	stepId,
+	message: "Step timed out",
+	noRetry: true
+}));
+const failUnexpectedStepRunMemoInput = (stepId, input) => Effect.fail(StepError.make({
+	stepId,
+	message: "Unexpected step result type: input",
+	cause: input
+}));
+//#endregion
+export { decodeMemo, decodeStepRunMemo, encodeStepRunMemo, failMemoDecode, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput, mapMemoDecodeError };

package/dist/internal/domain/ExecutionInput.d.ts

@@ -0,0 +1,40 @@
+import { StepInfo } from "./StepInfo.js";
+import { SDKRequestBody } from "../protocol.js";
+import { Memo } from "./Memo.js";
+import { Context, Schema } from "effect";
+
+//#region src/internal/domain/ExecutionInput.d.ts
+declare const ExecutionEvent_base: Schema.Class<ExecutionEvent, Schema.Struct<{
+  readonly id: Schema.optional<Schema.String>;
+  readonly name: Schema.String;
+  readonly data: Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly ts: Schema.optional<Schema.Number>;
+  readonly user: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly v: Schema.optional<Schema.String>;
+}>, {}>;
+declare class ExecutionEvent extends ExecutionEvent_base {}
+declare const RunContext_base: Schema.Class<RunContext, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly attempt: Schema.Number;
+  readonly maxAttempts: Schema.Number;
+}>, {}>;
+declare class RunContext extends RunContext_base {}
+declare const ExecutionInput_base: Schema.Class<ExecutionInput, Schema.Struct<{
+  readonly event: typeof ExecutionEvent;
+  readonly events: Schema.$Array<typeof ExecutionEvent>;
+  readonly steps: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly run: typeof RunContext;
+  readonly requestedStepHash: Schema.Option<Schema.String>;
+  readonly disableImmediateExecution: Schema.Boolean;
+}>, {}>;
+declare class ExecutionInput extends ExecutionInput_base {
+  static fromSdkRequestBody(request: SDKRequestBody): ExecutionInput;
+  memoForStep(info: StepInfo): Memo;
+  shouldExecuteStep(info: StepInfo): boolean;
+  shouldPlanStep(info: StepInfo): boolean;
+  isFunctionRun(): boolean;
+}
+declare const CurrentExecutionInput_base: Context.ServiceClass<CurrentExecutionInput, "effect-inngest/internal/domain/CurrentExecutionInput", ExecutionInput>;
+declare class CurrentExecutionInput extends CurrentExecutionInput_base {}
+//#endregion
+export { CurrentExecutionInput, ExecutionInput };

package/dist/internal/domain/ExecutionInput.js

@@ -0,0 +1,57 @@
+import { decode } from "./Memo.js";
+import { Context, Equal, Option, Schema } from "effect";
+//#region src/internal/domain/ExecutionInput.ts
+var ExecutionEvent = class extends Schema.Class("effect-inngest/internal/domain/ExecutionEvent")({
+	id: Schema.optional(Schema.String),
+	name: Schema.String,
+	data: Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown)),
+	ts: Schema.optional(Schema.Number),
+	user: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	v: Schema.optional(Schema.String)
+}) {};
+var RunContext = class extends Schema.Class("effect-inngest/internal/domain/RunContext")({
+	id: Schema.String,
+	attempt: Schema.Number,
+	maxAttempts: Schema.Number
+}) {};
+var ExecutionInput = class ExecutionInput extends Schema.Class("effect-inngest/internal/domain/ExecutionInput")({
+	event: ExecutionEvent,
+	events: Schema.Array(ExecutionEvent),
+	steps: Schema.Record(Schema.String, Schema.Unknown),
+	run: RunContext,
+	requestedStepHash: Schema.Option(Schema.String),
+	disableImmediateExecution: Schema.Boolean
+}) {
+	static fromSdkRequestBody(request) {
+		return ExecutionInput.make({
+			event: ExecutionEvent.make(request.event),
+			events: request.events.map((event) => ExecutionEvent.make(event)),
+			steps: request.steps,
+			run: RunContext.make({
+				id: request.ctx.run_id,
+				attempt: request.ctx.attempt,
+				maxAttempts: request.ctx.max_attempts
+			}),
+			requestedStepHash: request.ctx.step_id === "step" ? Option.none() : Option.some(request.ctx.step_id),
+			disableImmediateExecution: request.ctx.disable_immediate_execution
+		});
+	}
+	memoForStep(info) {
+		return decode(this.steps[info.hash]);
+	}
+	shouldExecuteStep(info) {
+		return Option.match(this.requestedStepHash, {
+			onNone: () => true,
+			onSome: Equal.equals(info.hash)
+		});
+	}
+	shouldPlanStep(info) {
+		return this.shouldExecuteStep(info) && this.isFunctionRun() && this.disableImmediateExecution;
+	}
+	isFunctionRun() {
+		return Option.isNone(this.requestedStepHash);
+	}
+};
+var CurrentExecutionInput = class extends Context.Service()("effect-inngest/internal/domain/CurrentExecutionInput") {};
+//#endregion
+export { CurrentExecutionInput, ExecutionInput };

package/dist/internal/domain/ExecutionSuspension.d.ts

@@ -0,0 +1,34 @@
+import { GeneratorOpcode as GeneratorOpcode$1 } from "../protocol.js";
+import { Failure, PlannedOpcode } from "./StepCommand.js";
+import { Option, Schema } from "effect";
+
+//#region src/internal/domain/ExecutionSuspension.d.ts
+type GeneratorOpcode = typeof GeneratorOpcode$1.Type;
+declare const SuspendedCommand_base: Schema.Class<SuspendedCommand, Schema.Struct<{
+  readonly opcode: typeof GeneratorOpcode$1;
+  readonly sequence: Schema.Option<Schema.Number>;
+  readonly retryAfterMs: Schema.Option<Schema.Number>;
+  readonly isFailure: Schema.Boolean;
+  readonly noRetry: Schema.Boolean;
+}>, {}>;
+declare class SuspendedCommand extends SuspendedCommand_base {
+  static fromPlanned(planned: PlannedOpcode): SuspendedCommand;
+  static fromOpcode(opcode: GeneratorOpcode, retryAfterMs?: Option.Option<number>): SuspendedCommand;
+  static fromFailure(failure: Failure): SuspendedCommand;
+}
+declare const ExecutionSuspension_base: Schema.Class<ExecutionSuspension, Schema.Struct<{
+  readonly completed: Schema.$Array<typeof GeneratorOpcode$1>;
+  readonly opcodes: Schema.$Array<typeof GeneratorOpcode$1>;
+  readonly suspendedCount: Schema.Number;
+  readonly retryAfterMs: Schema.Option<Schema.Number>;
+  readonly hasFailure: Schema.Boolean;
+  readonly noRetry: Schema.Boolean;
+}>, {}>;
+declare class ExecutionSuspension extends ExecutionSuspension_base {
+  static from(args: {
+    readonly completed: ReadonlyArray<GeneratorOpcode>;
+    readonly suspended: ReadonlyArray<SuspendedCommand>;
+  }): ExecutionSuspension;
+}
+//#endregion
+export { ExecutionSuspension, GeneratorOpcode };

package/dist/internal/domain/ExecutionSuspension.js

@@ -0,0 +1,64 @@
+import { GeneratorOpcode } from "../protocol.js";
+import { Array, Option, Schema } from "effect";
+//#region src/internal/domain/ExecutionSuspension.ts
+var SuspendedCommand = class SuspendedCommand extends Schema.Class("effect-inngest/internal/domain/SuspendedCommand")({
+	opcode: GeneratorOpcode,
+	sequence: Schema.Option(Schema.Number),
+	retryAfterMs: Schema.Option(Schema.Number),
+	isFailure: Schema.Boolean,
+	noRetry: Schema.Boolean
+}) {
+	static fromPlanned(planned) {
+		return SuspendedCommand.make({
+			opcode: planned.opcode,
+			sequence: Option.some(planned.sequence),
+			retryAfterMs: Option.none(),
+			isFailure: false,
+			noRetry: false
+		});
+	}
+	static fromOpcode(opcode, retryAfterMs = Option.none()) {
+		return SuspendedCommand.make({
+			opcode,
+			sequence: Option.none(),
+			retryAfterMs,
+			isFailure: false,
+			noRetry: false
+		});
+	}
+	static fromFailure(failure) {
+		return SuspendedCommand.make({
+			opcode: failure.opcode,
+			sequence: Option.none(),
+			retryAfterMs: failure.retryAfterMs,
+			isFailure: true,
+			noRetry: failure.noRetry
+		});
+	}
+};
+var ExecutionSuspension = class ExecutionSuspension extends Schema.Class("effect-inngest/internal/domain/ExecutionSuspension")({
+	completed: Schema.Array(GeneratorOpcode),
+	opcodes: Schema.Array(GeneratorOpcode),
+	suspendedCount: Schema.Number,
+	retryAfterMs: Schema.Option(Schema.Number),
+	hasFailure: Schema.Boolean,
+	noRetry: Schema.Boolean
+}) {
+	static from(args) {
+		const suspended = args.suspended.toSorted((a, b) => {
+			if (Option.isNone(a.sequence) || Option.isNone(b.sequence)) return 0;
+			return a.sequence.value - b.sequence.value;
+		});
+		const opcodes = [...args.completed, ...suspended.map((entry) => entry.opcode)];
+		return ExecutionSuspension.make({
+			completed: [...args.completed],
+			opcodes,
+			suspendedCount: args.suspended.length,
+			retryAfterMs: Array.findFirst(suspended, (entry) => Option.isSome(entry.retryAfterMs)).pipe(Option.flatMap((entry) => entry.retryAfterMs)),
+			hasFailure: suspended.some((entry) => entry.isFailure),
+			noRetry: suspended.some((entry) => entry.noRetry)
+		});
+	}
+};
+//#endregion
+export { ExecutionSuspension, SuspendedCommand };

package/dist/internal/domain/FunctionDefinition.js

@@ -0,0 +1,13 @@
+import { Array, Option, Predicate, Schema } from "effect";
+//#region src/internal/domain/FunctionDefinition.ts
+const EventSchemaShape = Schema.declare((value) => Schema.isSchema(value) && Predicate.hasProperty(value, "identifier") && Predicate.isString(value.identifier));
+const EventTriggerShape = Schema.Struct({ event: EventSchemaShape });
+const isEventTriggerShape = Schema.is(EventTriggerShape);
+const isEventTrigger = (trigger) => isEventTriggerShape(trigger);
+const eventSchemas = (fn) => Array.map(Array.filter(fn.triggers, isEventTrigger), (trigger) => trigger.event);
+const eventSchemaFor = (args) => {
+	const events = eventSchemas(args.fn);
+	return Option.fromNullishOr(events.find((event) => event.identifier === args.eventName));
+};
+//#endregion
+export { eventSchemaFor, eventSchemas };

package/dist/internal/domain/Memo.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+
+//#region src/internal/domain/Memo.d.ts
+declare const MemoData_base: Schema.Class<MemoData, Schema.TaggedStruct<"MemoData", {
+  readonly data: Schema.Unknown;
+}>, {}>;
+declare class MemoData extends MemoData_base {}
+declare const MemoError_base: Schema.Class<MemoError, Schema.TaggedStruct<"MemoError", {
+  readonly error: Schema.Unknown;
+}>, {}>;
+declare class MemoError extends MemoError_base {}
+declare const MemoInput_base: Schema.Class<MemoInput, Schema.TaggedStruct<"MemoInput", {
+  readonly input: Schema.Unknown;
+}>, {}>;
+declare class MemoInput extends MemoInput_base {}
+declare const MemoTimeout_base: Schema.Class<MemoTimeout, Schema.TaggedStruct<"MemoTimeout", {}>, {}>;
+declare class MemoTimeout extends MemoTimeout_base {}
+declare const MemoNone_base: Schema.Class<MemoNone, Schema.TaggedStruct<"MemoNone", {}>, {}>;
+declare class MemoNone extends MemoNone_base {}
+type Memo = MemoData | MemoError | MemoInput | MemoTimeout | MemoNone;
+//#endregion
+export { Memo };

package/dist/internal/domain/Memo.js

@@ -0,0 +1,18 @@
+import { Match, Predicate, Schema } from "effect";
+//#region src/internal/domain/Memo.ts
+const IncomingMemo = Schema.Struct({
+	data: Schema.optional(Schema.Unknown),
+	error: Schema.optional(Schema.Unknown),
+	input: Schema.optional(Schema.Unknown)
+});
+const IncomingMemoData = Schema.Struct({ data: Schema.Unknown });
+const IncomingMemoError = Schema.Struct({ error: Schema.Unknown });
+const IncomingMemoInput = Schema.Struct({ input: Schema.Unknown });
+var MemoData = class extends Schema.TaggedClass()("MemoData", { data: Schema.Unknown }) {};
+var MemoError = class extends Schema.TaggedClass()("MemoError", { error: Schema.Unknown }) {};
+var MemoInput = class extends Schema.TaggedClass()("MemoInput", { input: Schema.Unknown }) {};
+var MemoTimeout = class extends Schema.TaggedClass()("MemoTimeout", {}) {};
+var MemoNone = class extends Schema.TaggedClass()("MemoNone", {}) {};
+const decode = (value) => Match.value(value).pipe(Match.when(Predicate.isNull, () => MemoTimeout.make({})), Match.when(Predicate.not(Schema.is(IncomingMemo)), () => MemoNone.make({})), Match.when(Schema.is(IncomingMemoError), ({ error }) => MemoError.make({ error })), Match.when(Schema.is(IncomingMemoInput), ({ input }) => MemoInput.make({ input })), Match.when(Schema.is(IncomingMemoData), ({ data }) => MemoData.make({ data })), Match.orElse(() => MemoNone.make({})));
+//#endregion
+export { decode };

package/dist/internal/domain/StepCommand.d.ts

@@ -0,0 +1,79 @@
+import { StepInfo } from "./StepInfo.js";
+import { GeneratorOpcode } from "../protocol.js";
+import { Schema } from "effect";
+
+//#region src/internal/domain/StepCommand.d.ts
+declare const Sleep_base: Schema.Class<Sleep, Schema.TaggedStruct<"Sleep", {
+  readonly info: typeof StepInfo;
+  readonly sequence: Schema.Number;
+  readonly duration: Schema.String;
+}>, {}>;
+declare class Sleep extends Sleep_base {}
+declare const WaitForEvent_base: Schema.Class<WaitForEvent, Schema.TaggedStruct<"WaitForEvent", {
+  readonly info: typeof StepInfo;
+  readonly sequence: Schema.Number;
+  readonly event: Schema.String;
+  readonly timeout: Schema.String;
+  readonly if: Schema.optional<Schema.String>;
+}>, {}>;
+declare class WaitForEvent extends WaitForEvent_base {}
+declare const InvokeFunction_base: Schema.Class<InvokeFunction, Schema.TaggedStruct<"InvokeFunction", {
+  readonly info: typeof StepInfo;
+  readonly sequence: Schema.Number;
+  readonly functionId: Schema.String;
+  readonly payload: Schema.Unknown;
+  readonly timeout: Schema.optional<Schema.String>;
+}>, {}>;
+declare class InvokeFunction extends InvokeFunction_base {}
+declare const StepRunResult_base: Schema.Class<StepRunResult, Schema.TaggedStruct<"StepRunResult", {
+  readonly info: typeof StepInfo;
+  readonly data: Schema.Unknown;
+}>, {}>;
+declare class StepRunResult extends StepRunResult_base {}
+declare const SendEventResult_base: Schema.Class<SendEventResult, Schema.TaggedStruct<"SendEventResult", {
+  readonly info: typeof StepInfo;
+  readonly data: Schema.Struct<{
+    readonly ids: Schema.$Array<Schema.String>;
+  }>;
+  readonly rawPayload: Schema.Unknown;
+}>, {}>;
+declare class SendEventResult extends SendEventResult_base {}
+declare const StepRunPlanned_base: Schema.Class<StepRunPlanned, Schema.TaggedStruct<"StepRunPlanned", {
+  readonly info: typeof StepInfo;
+  readonly sequence: Schema.Number;
+}>, {}>;
+declare class StepRunPlanned extends StepRunPlanned_base {}
+declare const SendEventPlanned_base: Schema.Class<SendEventPlanned, Schema.TaggedStruct<"SendEventPlanned", {
+  readonly info: typeof StepInfo;
+  readonly sequence: Schema.Number;
+}>, {}>;
+declare class SendEventPlanned extends SendEventPlanned_base {}
+declare const StepRunError_base: Schema.Class<StepRunError, Schema.TaggedStruct<"StepRunError", {
+  readonly info: typeof StepInfo;
+  readonly error: Schema.Unknown;
+  readonly noRetry: Schema.optional<Schema.Boolean>;
+  readonly retryAfterMs: Schema.optional<Schema.Number>;
+}>, {}>;
+declare class StepRunError extends StepRunError_base {}
+declare const StepRunFailed_base: Schema.Class<StepRunFailed, Schema.TaggedStruct<"StepRunFailed", {
+  readonly info: typeof StepInfo;
+  readonly error: Schema.Unknown;
+}>, {}>;
+declare class StepRunFailed extends StepRunFailed_base {}
+declare const Failure_base: Schema.Class<Failure, Schema.Struct<{
+  readonly opcode: typeof GeneratorOpcode;
+  readonly retryAfterMs: Schema.Option<Schema.Number>;
+  readonly noRetry: Schema.Boolean;
+}>, {}>;
+declare class Failure extends Failure_base {}
+declare const PlannedOpcode_base: Schema.Class<PlannedOpcode, Schema.Struct<{
+  readonly opcode: typeof GeneratorOpcode;
+  readonly sequence: Schema.Number;
+}>, {}>;
+declare class PlannedOpcode extends PlannedOpcode_base {}
+type YieldCommand = Sleep | WaitForEvent | InvokeFunction;
+type ResultCommand = StepRunResult | SendEventResult;
+type PlanCommand = YieldCommand | StepRunPlanned | SendEventPlanned;
+type ErrorCommand = StepRunError | StepRunFailed;
+//#endregion
+export { ErrorCommand, Failure, PlanCommand, PlannedOpcode, ResultCommand, YieldCommand };

package/dist/internal/domain/StepCommand.js

@@ -0,0 +1,124 @@
+import { GeneratorOpcode, UserError } from "../protocol.js";
+import { isNonRetriableError, isRetryAfterError } from "../errors.js";
+import { StepInfo } from "./StepInfo.js";
+import { Duration, Match, Option, Schema } from "effect";
+//#region src/internal/domain/StepCommand.ts
+var Sleep = class extends Schema.TaggedClass()("Sleep", {
+	info: StepInfo,
+	sequence: Schema.Number,
+	duration: Schema.String
+}) {};
+var WaitForEvent = class extends Schema.TaggedClass()("WaitForEvent", {
+	info: StepInfo,
+	sequence: Schema.Number,
+	event: Schema.String,
+	timeout: Schema.String,
+	if: Schema.optional(Schema.String)
+}) {};
+var InvokeFunction = class extends Schema.TaggedClass()("InvokeFunction", {
+	info: StepInfo,
+	sequence: Schema.Number,
+	functionId: Schema.String,
+	payload: Schema.Unknown,
+	timeout: Schema.optional(Schema.String)
+}) {};
+var StepRunResult = class extends Schema.TaggedClass()("StepRunResult", {
+	info: StepInfo,
+	data: Schema.Unknown
+}) {};
+var SendEventResult = class extends Schema.TaggedClass()("SendEventResult", {
+	info: StepInfo,
+	data: Schema.Struct({ ids: Schema.Array(Schema.String) }),
+	rawPayload: Schema.Unknown
+}) {};
+var StepRunPlanned = class extends Schema.TaggedClass()("StepRunPlanned", {
+	info: StepInfo,
+	sequence: Schema.Number
+}) {};
+var SendEventPlanned = class extends Schema.TaggedClass()("SendEventPlanned", {
+	info: StepInfo,
+	sequence: Schema.Number
+}) {};
+var StepRunError = class extends Schema.TaggedClass()("StepRunError", {
+	info: StepInfo,
+	error: Schema.Unknown,
+	noRetry: Schema.optional(Schema.Boolean),
+	retryAfterMs: Schema.optional(Schema.Number)
+}) {};
+var StepRunFailed = class extends Schema.TaggedClass()("StepRunFailed", {
+	info: StepInfo,
+	error: Schema.Unknown
+}) {};
+var Failure = class extends Schema.Class("effect-inngest/internal/domain/StepCommand/Failure")({
+	opcode: GeneratorOpcode,
+	retryAfterMs: Schema.Option(Schema.Number),
+	noRetry: Schema.Boolean
+}) {};
+var PlannedOpcode = class extends Schema.Class("effect-inngest/internal/domain/StepCommand/PlannedOpcode")({
+	opcode: GeneratorOpcode,
+	sequence: Schema.Number
+}) {};
+const stepRunFailureForAttempt = (args) => {
+	const noRetry = isNonRetriableError(args.error) ? true : void 0;
+	const retryAfterMs = isRetryAfterError(args.error) ? Duration.toMillis(args.error.retryAfter) : void 0;
+	return noRetry === true || args.attempt >= args.maxAttempts - 1 ? StepRunFailed.make({
+		info: args.info,
+		error: args.error
+	}) : StepRunError.make({
+		info: args.info,
+		error: args.error,
+		noRetry,
+		retryAfterMs
+	});
+};
+const suspension = (command) => Match.value(command).pipe(Match.tag("Sleep", (cmd) => GeneratorOpcode.sleep({
+	info: cmd.info,
+	duration: cmd.duration
+})), Match.tag("WaitForEvent", (cmd) => GeneratorOpcode.waitForEvent({
+	info: cmd.info,
+	event: cmd.event,
+	timeout: cmd.timeout,
+	if: cmd.if
+})), Match.tag("InvokeFunction", (cmd) => GeneratorOpcode.invokeFunction({
+	info: cmd.info,
+	functionId: cmd.functionId,
+	payload: cmd.payload,
+	timeout: cmd.timeout
+})), Match.exhaustive);
+const completion = (command) => Match.value(command).pipe(Match.tag("StepRunResult", (cmd) => GeneratorOpcode.stepRunResponse({
+	info: cmd.info,
+	data: cmd.data
+})), Match.tag("SendEventResult", (cmd) => GeneratorOpcode.sendEventStepRunResponse({
+	info: cmd.info,
+	data: cmd.data
+})), Match.exhaustive);
+const checkpoint = (command) => Match.value(command).pipe(Match.tag("StepRunResult", (cmd) => GeneratorOpcode.stepRun({
+	info: cmd.info,
+	data: cmd.data
+})), Match.tag("SendEventResult", (cmd) => GeneratorOpcode.sendEventStepRun({
+	info: cmd.info,
+	data: cmd.data,
+	rawPayload: cmd.rawPayload
+})), Match.exhaustive);
+const plan = (command) => PlannedOpcode.make({
+	opcode: Match.value(command).pipe(Match.tag("Sleep", (cmd) => suspension(cmd)), Match.tag("WaitForEvent", (cmd) => suspension(cmd)), Match.tag("InvokeFunction", (cmd) => suspension(cmd)), Match.tag("StepRunPlanned", (cmd) => GeneratorOpcode.stepPlanned(cmd.info)), Match.tag("SendEventPlanned", (cmd) => GeneratorOpcode.sendEventStepPlanned(cmd.info)), Match.exhaustive),
+	sequence: command.sequence
+});
+const failure = (command) => Match.value(command).pipe(Match.tag("StepRunError", (cmd) => Failure.make({
+	opcode: GeneratorOpcode.stepError({
+		info: cmd.info,
+		error: UserError.fromUnknown(cmd.error),
+		noRetry: cmd.noRetry
+	}),
+	retryAfterMs: Option.fromNullishOr(cmd.retryAfterMs),
+	noRetry: cmd.noRetry === true
+})), Match.tag("StepRunFailed", (cmd) => Failure.make({
+	opcode: GeneratorOpcode.stepFailed({
+		info: cmd.info,
+		error: UserError.fromUnknown(cmd.error)
+	}),
+	retryAfterMs: Option.none(),
+	noRetry: true
+})), Match.exhaustive);
+//#endregion
+export { InvokeFunction, SendEventPlanned, SendEventResult, Sleep, StepRunError, StepRunPlanned, StepRunResult, WaitForEvent, checkpoint, completion, failure, plan, stepRunFailureForAttempt };

package/dist/internal/domain/StepInfo.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+//#region src/internal/domain/StepInfo.d.ts
+declare const StepInfo_base: Schema.Class<StepInfo, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+  readonly hash: Schema.String;
+  readonly rawStepArg: Schema.Unknown;
+}>, {}>;
+declare class StepInfo extends StepInfo_base {}
+//#endregion
+export { StepInfo };

package/dist/internal/domain/StepInfo.js

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+//#region src/internal/domain/StepInfo.ts
+var StepInfo = class extends Schema.Class("effect-inngest/internal/domain/StepInfo")({
+	id: Schema.String,
+	name: Schema.String,
+	hash: Schema.String,
+	rawStepArg: Schema.Unknown
+}) {};
+//#endregion
+export { StepInfo };

package/dist/internal/domain/StepInput.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+
+//#region src/internal/domain/StepInput.d.ts
+declare const StepInput: Schema.Union<readonly [Schema.String, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.optional<Schema.String>;
+}>]>;
+type StepInput = typeof StepInput.Type;
+//#endregion
+export { StepInput };