effect-inngest 0.3.0-beta.4 → 0.4.0-beta2

package/dist/Group.d.ts

@@ -1,6 +1,7 @@
 import { InngestClient } from "./Client.js";
 import { InngestFunction } from "./Function.js";
 import { HandlerContext } from "./internal/runtime/HandlerContext.js";
+import { StepTools } from "./internal/runtime/StepTools.js";
 import { Context, Effect, Layer } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as _$effect_unstable_http_HttpServerRequest0 from "effect/unstable/http/HttpServerRequest";
@@ -24,7 +25,7 @@ type TypeId = typeof TypeId;
  * @since 0.1.0
  * @category models
  */
-type HandlerFn<F extends InngestFunction.Any> = (context: HandlerContext<F>) => Effect.Effect<InngestFunction.Success<F>, unknown, unknown>;
+type HandlerFn<F extends InngestFunction.Any> = (context: HandlerContext<F>) => Effect.Effect<unknown, unknown, unknown>;
 /**
  * @since 0.1.0
  * @category models
@@ -41,12 +42,13 @@ type HandlerFrom<Fns extends InngestFunction.Any, Tag extends InngestFunction.Ta
  * @since 0.1.0
  * @category models
  */
-type HandlersRequirements<H> = H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>> ? R : never;
+type RuntimeRequirements = InngestClient | StepTools;
+type HandlersRequirements<H> = H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>> ? Exclude<R, RuntimeRequirements> : never;
 /**
  * @since 0.1.0
  * @category models
  */
-type HandlerRequirements<Handler> = Handler extends ((...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>) ? R : never;
+type HandlerRequirements<Handler> = Handler extends ((...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>) ? Exclude<R, RuntimeRequirements> : never;
 /**
  * A nominal type representing a registered handler for a specific function tag.
  * @since 0.1.0
@@ -63,7 +65,7 @@ interface Handler<Tag extends string> {
  * @since 0.1.0
  * @category models
  */
-type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer Tag, infer _Triggers, infer _Success> ? Handler<Tag> : never;
+type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer Tag, infer _Triggers> ? Handler<Tag> : never;
 /**
  * @since 0.1.0
  * @category models
@@ -88,9 +90,7 @@ interface InngestGroup<Fns extends InngestFunction.Any> {
    */
   readonly accessHandler: <Tag extends InngestFunction.Tag<Fns>>(tag: Tag) => Effect.Effect<(context: HandlerContext<Extract<Fns, {
     readonly _tag: Tag;
-  }>>) => Effect.Effect<InngestFunction.Success<Extract<Fns, {
-    readonly _tag: Tag;
-  }>>, unknown>, never, Handler<Tag>>;
+  }>>) => Effect.Effect<unknown, unknown>, never, Handler<Tag>>;
 }
 /**
  * @since 0.1.0
@@ -127,7 +127,7 @@ declare const make: <Fns extends ReadonlyArray<InngestFunction.Any>>(...fns: Fns
  * )
  * ```
  */
-declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$effect_unstable_http_HttpServerResponse0.HttpServerResponse, never, InngestClient | _$effect_unstable_http_HttpServerRequest0.HttpServerRequest | HttpClient.HttpClient>;
+declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$effect_unstable_http_HttpServerResponse0.HttpServerResponse, never, InngestClient | HttpClient.HttpClient | _$effect_unstable_http_HttpServerRequest0.HttpServerRequest>;
 /**
  * Create a standalone web handler from an InngestGroup.
  *

package/dist/Group.js

@@ -1,4 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import "./internal/runtime/StepTools.js";
 import "./internal/runtime/HandlerContext.js";
 import { toHttpApp as toHttpApp$1, toWebHandler as toWebHandler$1 } from "./internal/serve/HttpApp.js";
 import { Context, Effect, Layer } from "effect";

package/dist/HttpApi.d.ts

@@ -49,13 +49,13 @@ declare const InngestApiGroup_base: HttpApiGroup.HttpApiGroup<"inngest", HttpApi
   readonly authentication_succeeded: Schema.optional<Schema.Union<readonly [Schema.Literal<false>, Schema.Null]>>;
   readonly capabilities: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
   readonly functions: Schema.optionalKey<Schema.$Array<Schema.Unknown>>;
-}>]>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>]>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
   readonly message: Schema.String;
   readonly modified: Schema.Boolean;
-}>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
   readonly fnId: Schema.String;
   readonly stepId: Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Unknown>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never>, false>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Unknown>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never>, false>;
 /**
  * @since 0.1.0
  * @category api

package/dist/Inngest.d.ts

@@ -0,0 +1,60 @@
+import { InngestClient } from "./Client.js";
+import { EventType as EventType$1 } from "./Event.js";
+import { InngestFunction } from "./Function.js";
+import { EventSchema } from "./internal/codec/EventPayload.js";
+import { SendEventError, StepError } from "./internal/errors.js";
+import { StepInput } from "./internal/domain/StepInput.js";
+import { InvokeOptions, OutgoingEvent, StepTools, WaitForEventOptions } from "./internal/runtime/StepTools.js";
+import { Duration, Effect, Option } from "effect";
+
+//#region src/Inngest.d.ts
+declare namespace Inngest_d_exports {
+  export { EventType, invoke, run, sendEvent, sleep, sleepUntil, waitForEvent };
+}
+/**
+ * Execute an Effect as a durable, memoized step.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const run: <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>) => Effect.Effect<A, StepError | Err, R | StepTools>;
+/**
+ * Sleep durably for a duration.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sleep: (id: StepInput, duration: Duration.Input) => Effect.Effect<void, never, StepTools>;
+/**
+ * Sleep durably until a timestamp.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sleepUntil: (id: StepInput, timestamp: Date | number | string) => Effect.Effect<void, never, StepTools>;
+/**
+ * Wait for a matching event.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const waitForEvent: <E extends EventSchema>(id: StepInput, event: E, options: WaitForEventOptions) => Effect.Effect<Option.Option<EventType$1<E>>, StepError, StepTools>;
+/**
+ * Invoke another Inngest function.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const invoke: <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>) => Effect.Effect<unknown, StepError, StepTools>;
+/**
+ * Send one or more Inngest events.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sendEvent: (id: StepInput, payload: OutgoingEvent | ReadonlyArray<OutgoingEvent>) => Effect.Effect<{
+  readonly ids: ReadonlyArray<string>;
+}, SendEventError, StepTools | InngestClient>;
+type EventType<E extends EventSchema> = EventType$1<E>;
+//#endregion
+export { Inngest_d_exports };

package/dist/Inngest.js

@@ -0,0 +1,61 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { StepTools } from "./internal/runtime/StepTools.js";
+import { Effect } from "effect";
+//#region src/Inngest.ts
+/**
+* Durable workflow operations for Inngest handlers.
+*
+* @since 0.1.0
+*/
+var Inngest_exports = /* @__PURE__ */ __exportAll({
+	invoke: () => invoke,
+	run: () => run,
+	sendEvent: () => sendEvent,
+	sleep: () => sleep,
+	sleepUntil: () => sleepUntil,
+	waitForEvent: () => waitForEvent
+});
+/**
+* Execute an Effect as a durable, memoized step.
+*
+* @since 0.1.0
+* @category steps
+*/
+const run = (id, effect) => Effect.flatMap(StepTools, (step) => step.run(id, effect));
+/**
+* Sleep durably for a duration.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sleep = (id, duration) => Effect.flatMap(StepTools, (step) => step.sleep(id, duration));
+/**
+* Sleep durably until a timestamp.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sleepUntil = (id, timestamp) => Effect.flatMap(StepTools, (step) => step.sleepUntil(id, timestamp));
+/**
+* Wait for a matching event.
+*
+* @since 0.1.0
+* @category steps
+*/
+const waitForEvent = (id, event, options) => Effect.flatMap(StepTools, (step) => step.waitForEvent(id, event, options));
+/**
+* Invoke another Inngest function.
+*
+* @since 0.1.0
+* @category steps
+*/
+const invoke = (id, options) => Effect.flatMap(StepTools, (step) => step.invoke(id, options));
+/**
+* Send one or more Inngest events.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sendEvent = (id, payload) => Effect.flatMap(StepTools, (step) => step.sendEvent(id, payload));
+//#endregion
+export { Inngest_exports };

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { Client_d_exports } from "./Client.js";
 import { Event_d_exports } from "./Event.js";
 import { Events_d_exports } from "./Events.js";
+import { Cron_d_exports } from "./Cron.js";
 import { Function_d_exports } from "./Function.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Group_d_exports } from "./Group.js";
 import { HttpApi_d_exports } from "./HttpApi.js";
-export { Client_d_exports as InngestClient, Event_d_exports as InngestEvent, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+import { Inngest_d_exports } from "./Inngest.js";
+export { Inngest_d_exports as Inngest, Client_d_exports as InngestClient, Cron_d_exports as InngestCron, Event_d_exports as InngestEvent, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/index.js

@@ -1,8 +1,10 @@
-import { Function_exports } from "./Function.js";
 import { Event_exports } from "./Event.js";
+import { Cron_exports } from "./Cron.js";
+import { Function_exports } from "./Function.js";
 import { Client_exports } from "./Client.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Events_exports } from "./Events.js";
 import { Group_exports } from "./Group.js";
+import { Inngest_exports } from "./Inngest.js";
 import { HttpApi_exports } from "./HttpApi.js";
-export { Client_exports as InngestClient, Event_exports as InngestEvent, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+export { Inngest_exports as Inngest, Client_exports as InngestClient, Cron_exports as InngestCron, Event_exports as InngestEvent, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/internal/codec/StepResult.js

@@ -1,5 +1,5 @@
 import { StepError } from "../errors.js";
-import { Effect, Function, Option, Predicate, Schema } from "effect";
+import { Effect, Function, Predicate } from "effect";
 //#region src/internal/codec/StepResult.ts
 const messageFromCause = (cause) => {
 	if (Predicate.hasProperty(cause, "cause")) {
@@ -25,16 +25,6 @@ const mapMemoDecodeError = Function.dual(2, (effect, stepId) => effect.pipe(Effe
 	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",
@@ -52,4 +42,4 @@ const failUnexpectedStepRunMemoInput = (stepId, input) => Effect.fail(StepError.
 	cause: input
 }));
 //#endregion
-export { decodeMemo, decodeStepRunMemo, encodeStepRunMemo, failMemoDecode, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput, mapMemoDecodeError };
+export { failMemoDecode, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput, mapMemoDecodeError };

package/dist/internal/driver.js

@@ -1,4 +1,5 @@
 import "./protocol.js";
+import "./runtime/StepTools.js";
 import { provide } from "./execution/ExecutionScope.js";
 import { run, withCheckpointDeadline } from "./execution/HandlerRun.js";
 import "./execution/ExecutionResult.js";

package/dist/internal/execution/HandlerRun.js

@@ -1,10 +1,11 @@
 import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { normalize } from "../utils/safe-stringify.js";
 import { make } from "../runtime/HandlerContext.js";
 import { Effect, Option, Schema } from "effect";
 //#region src/internal/execution/HandlerRun.ts
 var HandlerSucceeded = class extends Schema.TaggedClass()("HandlerSucceeded", { value: Schema.Unknown }) {};
 Schema.TaggedClass()("CheckpointDeadlineElapsed", {});
-const run = (args) => make({ fn: args.fn }).pipe(Effect.flatMap(args.handler), Effect.map((value) => HandlerSucceeded.make({ value })));
+const run = (args) => make({ fn: args.fn }).pipe(Effect.flatMap(args.handler), Effect.map((value) => HandlerSucceeded.make({ value: normalize(value) })));
 const withCheckpointDeadline = (effect) => Effect.gen(function* () {
 	const checkpoint = yield* CurrentCheckpoint;
 	return yield* Option.match(checkpoint, {

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

@@ -1,12 +1,10 @@
 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

package/dist/internal/runtime/HandlerContext.js

@@ -1,17 +1,14 @@
 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
 	};
 });

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

@@ -8,13 +8,9 @@ import { StepInput } from "../domain/StepInput.js";
 import { HandlerFiberScope } from "./HandlerFiberScope.js";
 import { StepCommandBus } from "./StepCommandBus.js";
 import { StepIdentity } from "./StepIdentity.js";
-import { Context, Duration, Effect, Layer, Option, Schema } from "effect";
+import { Context, Duration, Effect, Layer, Option } from "effect";
 
 //#region src/internal/runtime/StepTools.d.ts
-type JsonSchema<A = unknown> = Schema.Codec<A, unknown, never, never>;
-interface RunOptions<S extends JsonSchema> {
-  readonly schema: S;
-}
 interface WaitForEventOptions {
   readonly timeout: Duration.Input;
   readonly if?: string;
@@ -29,8 +25,7 @@ type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventPayloa
   readonly data: InngestFunction.EventPayload<F>;
 };
 interface Run {
-  <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
-  <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
+  <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>): Effect.Effect<A, StepError | Err, R>;
 }
 interface Sleep {
   (id: StepInput, duration: Duration.Input): Effect.Effect<void>;
@@ -42,7 +37,7 @@ interface WaitForEvent {
   <E extends EventSchema>(id: StepInput, event: E, options: WaitForEventOptions): Effect.Effect<Option.Option<EventType<E>>, StepError>;
 }
 interface Invoke {
-  <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>): Effect.Effect<InngestFunction.Success<F>, StepError>;
+  <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>): Effect.Effect<unknown, StepError>;
 }
 interface OutgoingEvent {
   readonly name: string;
@@ -66,18 +61,15 @@ declare namespace StepTools {
 declare const StepTools_base: Context.ServiceClass<StepTools, "effect-inngest/internal/runtime/StepTools", StepTools.Service>;
 declare class StepTools extends StepTools_base {
   static readonly make: Effect.Effect<{
-    run: {
-      <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
-      <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
-    };
+    run: <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>) => Effect.Effect<A, StepError | Err, Exclude<R, InngestConfig | CurrentExecutionInput | HandlerFiberScope | StepCommandBus | StepIdentity>>;
     sleep: Sleep;
     sleepUntil: SleepUntil;
     waitForEvent: WaitForEvent;
     invoke: Invoke;
     sendEvent: SendEvent;
-  }, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
-  static readonly layer: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
-  static readonly live: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | HandlerFiberScope>;
+  }, never, InngestConfig | CurrentExecutionInput | HandlerFiberScope | StepCommandBus | StepIdentity>;
+  static readonly layer: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | HandlerFiberScope | StepCommandBus | StepIdentity>;
+  static readonly live: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | HandlerFiberScope | StepIdentity>;
 }
 //#endregion
-export { StepTools };
+export { InvokeOptions, OutgoingEvent, StepTools, WaitForEventOptions };

package/dist/internal/runtime/StepTools.js

@@ -10,7 +10,7 @@ import { sleep } from "./steps/SleepStep.js";
 import { sleepUntil } from "./steps/SleepUntilStep.js";
 import { run } from "./steps/StepRun.js";
 import { waitForEvent } from "./steps/WaitForEventStep.js";
-import { Context, Effect, Layer, Predicate, pipe } from "effect";
+import { Context, Effect, Layer, pipe } from "effect";
 //#region src/internal/runtime/StepTools.ts
 var StepTools = class extends Context.Service()("effect-inngest/internal/runtime/StepTools") {
 	static make = Effect.gen(function* () {
@@ -21,13 +21,7 @@ var StepTools = class extends Context.Service()("effect-inngest/internal/runtime
 		const bus = yield* StepCommandBus;
 		const handlerFiberScope = yield* HandlerFiberScope;
 		const runtime = pipe(Context.make(StepIdentity, identity), Context.add(StepCommandBus, bus), Context.add(CurrentExecutionInput, input), Context.add(CurrentCheckpoint, checkpoint), Context.add(InngestConfig, config), Context.add(HandlerFiberScope, handlerFiberScope));
-		function run$1(id, effect, options) {
-			if (Predicate.isNotUndefined(options)) return run({
-				input,
-				id: identity.reserve(id),
-				effect,
-				options
-			}).pipe(Effect.provide(runtime));
+		function run$1(id, effect) {
 			return run({
 				input,
 				id: identity.reserve(id),

package/dist/internal/runtime/steps/InvokeStep.js

@@ -4,7 +4,6 @@ import { StepError } from "../../errors.js";
 import { InvokeFunction } from "../../domain/StepCommand.js";
 import { StepCommandBus } from "../StepCommandBus.js";
 import { StepIdentity } from "../StepIdentity.js";
-import { decodeMemo } from "../../codec/StepResult.js";
 import { Duration, Effect, Match, Predicate, Schema } from "effect";
 //#region src/internal/runtime/steps/InvokeStep.ts
 const invoke = (args) => Effect.gen(function* () {
@@ -13,7 +12,7 @@ const invoke = (args) => Effect.gen(function* () {
 	const bus = yield* StepCommandBus;
 	const info = yield* identity.resolve(args.id);
 	const memo = args.input.memoForStep(info);
-	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeMemo(Schema.toCodecJson(args.options.function.success), info.id)(data)), Match.tag("MemoError", ({ error }) => Effect.fail(StepError.make({
+	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => Effect.fail(StepError.make({
 		stepId: info.id,
 		message: Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed",
 		cause: error

package/dist/internal/runtime/steps/StepRun.js

@@ -1,46 +1,52 @@
 import { StepRunError, StepRunPlanned, StepRunResult, stepRunFailureForAttempt } from "../../domain/StepCommand.js";
 import { StepCommandBus } from "../StepCommandBus.js";
 import { StepIdentity } from "../StepIdentity.js";
-import { decodeStepRunMemo, encodeStepRunMemo, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput } from "../../codec/StepResult.js";
-import { Effect, Match, Option, Schema } from "effect";
+import { failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput } from "../../codec/StepResult.js";
+import { normalize } from "../../utils/safe-stringify.js";
+import { Effect, Match } from "effect";
 //#region src/internal/runtime/steps/StepRun.ts
 function run(args) {
-	const memoCodec = args.options ? Option.some(Schema.toCodecJson(args.options.schema)) : Option.none();
 	return Effect.gen(function* () {
 		const identity = yield* StepIdentity;
 		const bus = yield* StepCommandBus;
 		const info = yield* identity.resolve(args.id);
 		const memo = args.input.memoForStep(info);
-		return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeStepRunMemo(memoCodec, info.id)(data)), Match.tag("MemoError", ({ error }) => failStepRunMemoError(info.id, error)), Match.tag("MemoTimeout", () => failStepRunMemoTimeout(info.id)), Match.tag("MemoInput", ({ input }) => failUnexpectedStepRunMemoInput(info.id, input)), Match.tag("MemoNone", () => Effect.gen(function* () {
-			if (!args.input.shouldExecuteStep(info)) return yield* Effect.void;
+		return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => failStepRunMemoError(info.id, error)), Match.tag("MemoTimeout", () => failStepRunMemoTimeout(info.id)), Match.tag("MemoInput", ({ input }) => failUnexpectedStepRunMemoInput(info.id, input)), Match.tag("MemoNone", () => Effect.gen(function* () {
+			if (!args.input.shouldExecuteStep(info)) return yield* Effect.interrupt;
 			const planned = StepRunPlanned.make({
 				info,
 				sequence: args.id.sequence
 			});
 			if (args.input.shouldPlanStep(info)) {
 				yield* bus.plan(planned);
-				return yield* Effect.void;
+				return yield* Effect.interrupt;
 			}
-			if (yield* bus.planCheckpointedRunBoundary(planned)) return yield* Effect.void;
+			if (yield* bus.planCheckpointedRunBoundary(planned)) return yield* Effect.interrupt;
 			return yield* args.effect.pipe(Effect.matchEffect({
-				onFailure: (error) => bus.fail(stepRunFailureForAttempt({
-					info,
-					error,
-					attempt: args.input.run.attempt,
-					maxAttempts: args.input.run.maxAttempts
-				})),
+				onFailure: (error) => Effect.gen(function* () {
+					yield* bus.fail(stepRunFailureForAttempt({
+						info,
+						error,
+						attempt: args.input.run.attempt,
+						maxAttempts: args.input.run.maxAttempts
+					}));
+					return yield* Effect.interrupt;
+				}),
 				onSuccess: (value) => Effect.gen(function* () {
-					const data = yield* encodeStepRunMemo(memoCodec, info.id)(value);
+					const data = normalize(value);
 					yield* bus.complete(StepRunResult.make({
 						info,
 						data
 					}));
-					return yield* decodeStepRunMemo(memoCodec, info.id)(data);
+					return data;
 				})
-			}), Effect.catchDefect((defect) => bus.fail(StepRunError.make({
-				info,
-				error: defect
-			}))));
+			}), Effect.catchDefect((defect) => Effect.gen(function* () {
+				yield* bus.fail(StepRunError.make({
+					info,
+					error: defect
+				}));
+				return yield* Effect.interrupt;
+			})));
 		})), Match.exhaustive);
 	});
 }

package/dist/internal/utils/safe-stringify.js

@@ -0,0 +1,50 @@
+import { Array, Option, Predicate } from "effect";
+//#region src/internal/utils/safe-stringify.ts
+const findReference = (state, value) => Array.findFirstIndex(state.stack, (candidate) => Object.is(candidate, value));
+const isTracked = (state, value) => Option.isSome(findReference(state, value));
+const pushReference = (state, key, value) => {
+	state.stack.push(value);
+	state.keys.push(key);
+};
+const trimToParent = (state, key, parentIndex) => {
+	state.stack.splice(parentIndex + 1);
+	state.keys.splice(parentIndex, Infinity, key);
+};
+const refreshParent = (state, key, parent) => {
+	Option.match(findReference(state, parent), {
+		onNone: () => {
+			if (Predicate.isObjectOrArray(parent)) pushReference(state, key, parent);
+		},
+		onSome: (parentIndex) => trimToParent(state, key, parentIndex)
+	});
+};
+const defaultCycleReplacer = (state) => function(_key, value) {
+	const valueIndex = Option.getOrElse(findReference(state, value), () => -1);
+	if (Object.is(state.stack[0], value)) return "[Circular ~]";
+	return `[Circular ~.${state.keys.slice(0, valueIndex).join(".")}]`;
+};
+function stringify(obj, replacer, spaces, cycleReplacer) {
+	return JSON.stringify(obj, getSerialize(replacer, cycleReplacer), spaces);
+}
+const normalize = (value) => {
+	const json = stringify(value, (_key, child) => {
+		if (!Predicate.isBigInt(child)) return child;
+	});
+	return Predicate.isUndefined(json) ? null : JSON.parse(json);
+};
+function getSerialize(replacer, cycleReplacer) {
+	const state = {
+		stack: [],
+		keys: []
+	};
+	const replaceCycle = cycleReplacer ?? defaultCycleReplacer(state);
+	return function(key, value) {
+		if (Array.isArrayNonEmpty(state.stack)) {
+			refreshParent(state, key, this);
+			if (Predicate.isObjectKeyword(value) && isTracked(state, value)) value = replaceCycle.call(this, key, value);
+		} else state.stack.push(value);
+		return replacer ? replacer.call(this, key, value) : value;
+	};
+}
+//#endregion
+export { normalize };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-inngest",
-  "version": "0.3.0-beta.4",
+  "version": "0.4.0-beta2",
   "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
   "keywords": [
     "background-jobs",
@@ -42,6 +42,10 @@
       "types": "./dist/Client.d.ts",
       "import": "./src/Client.ts"
     },
+    "./Cron": {
+      "types": "./dist/Cron.d.ts",
+      "import": "./src/Cron.ts"
+    },
     "./Event": {
       "types": "./dist/Event.d.ts",
       "import": "./src/Event.ts"
@@ -62,6 +66,10 @@
       "types": "./dist/HttpApi.d.ts",
       "import": "./src/HttpApi.ts"
     },
+    "./Inngest": {
+      "types": "./dist/Inngest.d.ts",
+      "import": "./src/Inngest.ts"
+    },
     "./internal/*": null
   },
   "publishConfig": {
@@ -75,6 +83,10 @@
         "types": "./dist/Client.d.ts",
         "import": "./dist/Client.js"
       },
+      "./Cron": {
+        "types": "./dist/Cron.d.ts",
+        "import": "./dist/Cron.js"
+      },
       "./Event": {
         "types": "./dist/Event.d.ts",
         "import": "./dist/Event.js"
@@ -95,6 +107,10 @@
         "types": "./dist/HttpApi.d.ts",
         "import": "./dist/HttpApi.js"
       },
+      "./Inngest": {
+        "types": "./dist/Inngest.d.ts",
+        "import": "./dist/Inngest.js"
+      },
       "./internal/*": null
     }
   },

package/src/Client.ts

@@ -253,7 +253,7 @@ const makeClient = (config: ClientConfig, httpClient: HttpClient.HttpClient): Ef
         );
       }
 
-      const key = config.eventKey ?? "NO_EVENT_KEY_SET";
+      const key = config.eventKey || "NO_EVENT_KEY_SET";
       const url = new URL(`e/${key}`, eventBaseUrl).toString();
       const eventNames = events.map((e) => e.name);
       const now = yield* Clock.currentTimeMillis;

package/src/Cron.ts

@@ -0,0 +1,33 @@
+/**
+ * Public cron trigger definitions.
+ *
+ * @since 0.1.0
+ */
+import { Predicate } from "effect";
+
+export const TypeId: unique symbol = Symbol.for("effect-inngest/Cron");
+export type TypeId = typeof TypeId;
+
+export interface CronOptions {
+  readonly jitter?: string;
+}
+
+export interface CronDefinition<Schedule extends string = string> {
+  readonly [TypeId]: TypeId;
+  readonly cron: Schedule;
+  readonly jitter?: string;
+}
+
+export function make<const Schedule extends string>(
+  schedule: Schedule,
+  options?: CronOptions,
+): CronDefinition<Schedule> {
+  return {
+    [TypeId]: TypeId,
+    cron: schedule,
+    ...(Predicate.isNotUndefined(options?.jitter) ? { jitter: options.jitter } : {}),
+  };
+}
+
+export const isCron = (value: unknown): value is CronDefinition =>
+  Predicate.hasProperty(value, TypeId) && value[TypeId] === TypeId;