effect-inngest 0.3.0-beta.3 → 0.4.0-beta1

package/README.md

@@ -25,7 +25,7 @@
 Effect Inngest brings the power of [Effect](https://effect.website) to [Inngest's](https://inngest.com) durable execution platform. Define event schemas once, and types flow automatically through triggers, handlers, and step operations — no manual annotations needed.
 
 ```typescript
-import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup, Inngest, InngestCron } from "effect-inngest";
 import { Effect, Schema, Layer } from "effect";
 
 const UserSignup = InngestEvent.make(
@@ -38,8 +38,7 @@ const UserSignup = InngestEvent.make(
 
 // Create a function — event type is inferred from the trigger
 const ProcessSignup = InngestFunction.make("process-signup", {
-  trigger: { event: UserSignup },
-  success: Schema.Void,
+  trigger: UserSignup,
 });
 
 // Create group and implement handler
@@ -48,12 +47,12 @@ const Group = InngestGroup.make(ProcessSignup);
 const UserOnboarded = InngestEvent.make("user/onboarded", Schema.Struct({ userId: Schema.String }));
 
 const Handlers = Group.toLayer({
-  "process-signup": ({ event, step }) =>
+  "process-signup": ({ event }) =>
     Effect.gen(function* () {
       // event is typed as { name: "user/signup", data: { userId, email } }
-      yield* step.run("send-welcome", sendWelcomeEmail(event.data.email));
-      yield* step.sleep("delay", "1 hour");
-      yield* step.sendEvent("notify", UserOnboarded.make({ userId: event.data.userId }));
+      yield* Inngest.run("send-welcome", sendWelcomeEmail(event.data.email));
+      yield* Inngest.sleep("delay", "1 hour");
+      yield* Inngest.sendEvent("notify", UserOnboarded.make({ userId: event.data.userId }));
     }),
 });
 ```
@@ -65,9 +64,9 @@ const Handlers = Group.toLayer({
 ## Features
 
 - 🧙‍♂️ **Full type inference** — Payload types flow from schemas through triggers to handlers
-- ⚡ **Effect-native steps** — `step.run`, `step.sleep`, `step.waitForEvent` return proper Effects
+- ⚡ **Effect-native steps** — `Inngest.run`, `Inngest.sleep`, `Inngest.waitForEvent` return proper Effects
 - 🔌 **Dependency injection** — Use Effect's Layer system for services in handlers
-- 🛡️ **Schema validation** — Define events once with Effect Schema, validated everywhere
+- 🛡️ **Event validation** — Define events once with Effect Schema, validated at the boundary
 - 🚀 **Zero boilerplate** — No code generation, no manual type annotations
 - 🔄 **Parallel execution** — Run steps concurrently with `Effect.all`
 - 🌐 **Multi-runtime** — Works with Bun, Node.js, and Cloudflare Workers
@@ -109,7 +108,7 @@ import { BunHttpServer, BunRuntime } from "@effect/platform-bun";
 import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
 import * as HttpServer from "@effect/platform/HttpServer";
 import { Duration, Effect, Layer, Schema } from "effect";
-import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup, Inngest, InngestCron } from "effect-inngest";
 
 // 1. Define your Inngest event definitions
 const UserSignup = InngestEvent.make(
@@ -124,39 +123,38 @@ const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ u
 
 // 2. Define your functions
 const ProcessSignup = InngestFunction.make("process-signup", {
-  trigger: { event: UserSignup },
-  success: Schema.Struct({ welcomed: Schema.Boolean }),
+  trigger: UserSignup,
 });
 
 const DailyDigest = InngestFunction.make("daily-digest", {
-  trigger: { cron: "0 9 * * *" },
-  success: Schema.Void,
+  trigger: InngestCron.make("0 9 * * *"),
 });
 
 // 3. Create function group and implement handlers
 const App = InngestGroup.make(ProcessSignup, DailyDigest);
 
 const Handlers = App.toLayer({
-  "process-signup": ({ event, step }) =>
+  "process-signup": ({ event }) =>
     Effect.gen(function* () {
       // event is typed as { name: "user/signup", data: { userId, email } }
       yield* Effect.log(`Processing signup for ${event.data.email}`);
 
-      // Durable value-returning steps need a replay schema
-      const user = yield* step.run("create-user", Effect.succeed({ id: event.data.userId, email: event.data.email }), {
-        schema: Schema.Struct({ id: Schema.String, email: Schema.String }),
-      });
+      // Durable value-returning steps are normalized through JSON on the wire
+      const user = yield* Inngest.run(
+        "create-user",
+        Effect.succeed({ id: event.data.userId, email: event.data.email }),
+      );
 
       // Sleep durably
-      yield* step.sleep("welcome-delay", Duration.seconds(5));
+      yield* Inngest.sleep("welcome-delay", Duration.seconds(5));
 
       // Send follow-up event
-      yield* step.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
+      yield* Inngest.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
 
       return { welcomed: true };
     }),
 
-  "daily-digest": ({ step }) => step.run("send-digest", Effect.log("Sending daily digest...")),
+  "daily-digest": () => Inngest.run("send-digest", Effect.log("Sending daily digest...")),
 });
 
 // 4. Create client and start server
@@ -200,7 +198,7 @@ import { FetchHttpClient } from "@effect/platform";
 import { BunHttpServer, BunRuntime } from "@effect/platform-bun";
 import { Duration, Effect, Layer, Schema } from "effect";
 import { InngestApiGroup, layerGroup } from "effect-inngest/HttpApi";
-import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup, Inngest, InngestCron } from "effect-inngest";
 
 // 1. Define your events
 const UserSignup = InngestEvent.make(
@@ -215,30 +213,29 @@ const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ u
 
 // 2. Define functions
 const ProcessSignup = InngestFunction.make("process-signup", {
-  trigger: { event: UserSignup },
-  success: Schema.Struct({ welcomed: Schema.Boolean }),
+  trigger: UserSignup,
 });
 
 const DailyDigest = InngestFunction.make("daily-digest", {
-  trigger: { cron: "0 9 * * *" },
-  success: Schema.Void,
+  trigger: InngestCron.make("0 9 * * *"),
 });
 
 // 3. Create group and handlers
 const App = InngestGroup.make(ProcessSignup, DailyDigest);
 
 const Handlers = App.toLayer({
-  "process-signup": ({ event, step }) =>
+  "process-signup": ({ event }) =>
     Effect.gen(function* () {
       yield* Effect.log(`Processing signup for ${event.data.email}`);
-      const user = yield* step.run("create-user", Effect.succeed({ id: event.data.userId, email: event.data.email }), {
-        schema: Schema.Struct({ id: Schema.String, email: Schema.String }),
-      });
-      yield* step.sleep("welcome-delay", Duration.seconds(5));
-      yield* step.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
+      const user = yield* Inngest.run(
+        "create-user",
+        Effect.succeed({ id: event.data.userId, email: event.data.email }),
+      );
+      yield* Inngest.sleep("welcome-delay", Duration.seconds(5));
+      yield* Inngest.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
       return { welcomed: true };
     }),
-  "daily-digest": ({ step }) => step.run("send-digest", Effect.log("Sending daily digest...")),
+  "daily-digest": () => Inngest.run("send-digest", Effect.log("Sending daily digest...")),
 });
 
 // 4. Create client
@@ -298,46 +295,44 @@ const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ u
 ### 2. Define your functions
 
 ```typescript
-import { InngestFunction } from "effect-inngest";
+import { InngestCron, InngestFunction } from "effect-inngest";
 
 // Event-triggered function
 const ProcessSignup = InngestFunction.make("process-signup", {
-  trigger: [{ event: UserSignup }], // pass multiple triggers as Array.
-  success: Schema.Struct({ welcomeEmailSent: Schema.Boolean }),
+  trigger: UserSignup,
 });
 
 // Cron-triggered function
 const DailyReport = InngestFunction.make("daily-report", {
-  trigger: { cron: "0 9 * * *" },
-  success: Schema.Void,
+  trigger: InngestCron.make("0 9 * * *"),
 });
 ```
 
 ### 3. Create a function group and implement handlers
 
 ```typescript
-import { InngestGroup } from "effect-inngest";
+import { InngestGroup, Inngest } from "effect-inngest";
 import { Effect, Duration } from "effect";
 
 const AppFunctions = InngestGroup.make(ProcessSignup, DailyReport);
 
 const HandlersLive = AppFunctions.toLayer({
-  "process-signup": ({ event, step }) =>
+  "process-signup": ({ event }) =>
     Effect.gen(function* () {
-      yield* step.run("create-user", createUser(event));
-      yield* step.sleep("delay", Duration.minutes(5));
-      yield* step.sendEvent("welcome", UserWelcomeSent.make({ userId: event.data.userId }));
+      yield* Inngest.run("create-user", createUser(event));
+      yield* Inngest.sleep("delay", Duration.minutes(5));
+      yield* Inngest.sendEvent("welcome", UserWelcomeSent.make({ userId: event.data.userId }));
       return { welcomeEmailSent: true };
     }),
 
-  "daily-report": ({ step }) => step.run("generate", Effect.log("Generating report...")),
+  "daily-report": () => Inngest.run("generate", Effect.log("Generating report...")),
 });
 ```
 
 ### 4. Create a web handler
 
 ```typescript
-import { InngestClient, InngestGroup } from "effect-inngest";
+import { InngestClient, InngestGroup, Inngest } from "effect-inngest";
 import { FetchHttpClient } from "@effect/platform";
 import { Layer } from "effect";
 
@@ -363,31 +358,31 @@ Bun.serve({ port: 3000, fetch: handler });
 All step operations are durable — they're memoized and survive retries:
 
 ```typescript
-({ step }) =>
+() =>
   Effect.gen(function* () {
-    // Run an Effect with memoization. Value-returning steps require a replay schema.
-    const user = yield* step.run("fetch-user", fetchUser(userId), { schema: User });
+    // Run an Effect with memoization. Values are replayed as normalized JSON.
+    const user = yield* Inngest.run("fetch-user", fetchUser(userId));
 
     // Sleep for a duration
-    yield* step.sleep("wait", Duration.hours(24));
+    yield* Inngest.sleep("wait", Duration.hours(24));
 
     // Sleep until a timestamp
-    yield* step.sleepUntil("deadline", new Date("2024-12-31"));
+    yield* Inngest.sleepUntil("deadline", new Date("2024-12-31"));
 
     // Wait for an event (returns Option)
-    const payment = yield* step.waitForEvent("await-payment", PaymentReceived, {
+    const payment = yield* Inngest.waitForEvent("await-payment", PaymentReceived, {
       timeout: Duration.days(7),
       if: `async.data.orderId == "${orderId}"`,
     });
 
     // Invoke another function
-    const result = yield* step.invoke("process", {
+    const result = yield* Inngest.invoke("process", {
       function: ProcessOrder,
-      data: { orderId: "123" },
+      data: OrderPlaced.make({ orderId: "123", items: [], total: 0 }),
     });
 
     // Send events
-    yield* step.sendEvent("notify", OrderShipped.make({ orderId }));
+    yield* Inngest.sendEvent("notify", OrderShipped.make({ orderId }));
   });
 ```
 
@@ -400,9 +395,9 @@ const [user, orders, prefs] =
   yield *
   Effect.all(
     [
-      step.run("user", fetchUser(id), { schema: User }),
-      step.run("orders", fetchOrders(id), { schema: Schema.Array(Order) }),
-      step.run("prefs", fetchPreferences(id), { schema: Preferences }),
+      Inngest.run("user", fetchUser(id)),
+      Inngest.run("orders", fetchOrders(id)),
+      Inngest.run("prefs", fetchPreferences(id)),
     ],
     { concurrency: "unbounded" },
   );
@@ -425,10 +420,10 @@ class EmailService extends Context.Tag("EmailService")<
 
 // Use in handler
 const HandlersLive = AppFunctions.toLayer({
-  "process-signup": ({ event, step }) =>
+  "process-signup": ({ event }) =>
     Effect.gen(function* () {
       const email = yield* EmailService;
-      yield* step.run("send", email.send(event.data.email, "Welcome!"));
+      yield* Inngest.run("send", email.send(event.data.email, "Welcome!"));
       return { welcomeEmailSent: true };
     }),
 });
@@ -451,7 +446,7 @@ Configure retries, concurrency, rate limiting, and more:
 
 ```typescript
 const ProcessOrder = InngestFunction.make("process-order", {
-  trigger: { event: OrderPlaced },
+  trigger: OrderPlaced,
   retries: 5,
   concurrency: { limit: 10, key: "event.data.userId" },
   rateLimit: { limit: 100, period: Duration.minutes(1) },
@@ -498,15 +493,14 @@ yield * Effect.fail(RetryAfterError.make({ message: "Rate limited", retryAfter:
 
 ### Step Methods
 
-| Method                                           | Description                                     |
-| ------------------------------------------------ | ----------------------------------------------- |
-| `step.run(id, effect)`                           | Execute a void effect with memoization          |
-| `step.run(id, effect, { schema })`               | Execute a value-returning effect with replay IO |
-| `step.sleep(id, duration)`                       | Sleep for a duration                            |
-| `step.sleepUntil(id, timestamp)`                 | Sleep until a timestamp                         |
-| `step.waitForEvent(id, InngestEvent, opts)`      | Wait for an event with timeout                  |
-| `step.invoke(id, opts)`                          | Invoke another function                         |
-| `step.sendEvent(id, InngestEvent.make(payload))` | Send events to Inngest                          |
+| Method                                              | Description                        |
+| --------------------------------------------------- | ---------------------------------- |
+| `Inngest.run(id, effect)`                           | Execute an Effect with memoization |
+| `Inngest.sleep(id, duration)`                       | Sleep for a duration               |
+| `Inngest.sleepUntil(id, timestamp)`                 | Sleep until a timestamp            |
+| `Inngest.waitForEvent(id, InngestEvent, opts)`      | Wait for an event with timeout     |
+| `Inngest.invoke(id, opts)`                          | Invoke another function            |
+| `Inngest.sendEvent(id, InngestEvent.make(payload))` | Send events to Inngest             |
 
 ---
 
@@ -520,11 +514,11 @@ See the [`examples/`](./examples) directory:
 
 This library is under active development. The following Inngest features are **not yet supported**:
 
-| Feature                | Status               |
-| ---------------------- | -------------------- |
-| Middleware             | 🚧 Not yet supported |
-| AI Steps (`step.ai.*`) | 🚧 Not yet supported |
-| Encryption             | 🚧 Not yet supported |
+| Feature                   | Status               |
+| ------------------------- | -------------------- |
+| Middleware                | 🚧 Not yet supported |
+| AI Steps (`Inngest.ai.*`) | 🚧 Not yet supported |
+| Encryption                | 🚧 Not yet supported |
 
 ---
 

package/dist/Client.js

@@ -86,7 +86,7 @@ const makeClient = (config, httpClient) => Effect.gen(function* () {
 			message: "Event key is required to send events in cloud mode",
 			events: events.map((e) => e.name)
 		}));
-		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/dist/Cron.d.ts

@@ -0,0 +1,17 @@
+declare namespace Cron_d_exports {
+  export { CronDefinition, CronOptions, TypeId, isCron, make };
+}
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+interface CronOptions {
+  readonly jitter?: string;
+}
+interface CronDefinition<Schedule extends string = string> {
+  readonly [TypeId]: TypeId;
+  readonly cron: Schedule;
+  readonly jitter?: string;
+}
+declare function make<const Schedule extends string>(schedule: Schedule, options?: CronOptions): CronDefinition<Schedule>;
+declare const isCron: (value: unknown) => value is CronDefinition;
+//#endregion
+export { CronDefinition, Cron_d_exports };

package/dist/Cron.js

@@ -0,0 +1,24 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Predicate } from "effect";
+//#region src/Cron.ts
+/**
+* Public cron trigger definitions.
+*
+* @since 0.1.0
+*/
+var Cron_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	isCron: () => isCron,
+	make: () => make
+});
+const TypeId = Symbol.for("effect-inngest/Cron");
+function make(schedule, options) {
+	return {
+		[TypeId]: TypeId,
+		cron: schedule,
+		...Predicate.isNotUndefined(options?.jitter) ? { jitter: options.jitter } : {}
+	};
+}
+const isCron = (value) => Predicate.hasProperty(value, TypeId) && value[TypeId] === TypeId;
+//#endregion
+export { Cron_exports, isCron };

package/dist/Events.d.ts

@@ -65,7 +65,7 @@ declare const FunctionCancelled: EventDefinition<"inngest/function.cancelled", S
   readonly correlation_id: Schema.optional<Schema.String>;
 }>>;
 /**
- * Sent when a function is invoked via step.invoke().
+ * Sent when a function is invoked via Inngest.invoke().
  * @since 0.1.0
  */
 declare const FunctionInvoked: EventDefinition<"inngest/function.invoked", Schema.StructWithRest<Schema.Struct<{

package/dist/Events.js

@@ -75,7 +75,7 @@ const FunctionCancelled = make("inngest/function.cancelled", Schema.Struct({
 	correlation_id: Schema.optional(Schema.String)
 }));
 /**
-* Sent when a function is invoked via step.invoke().
+* Sent when a function is invoked via Inngest.invoke().
 * @since 0.1.0
 */
 const FunctionInvoked = make("inngest/function.invoked", Schema.StructWithRest(Schema.Struct({ _inngest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)) }), [Schema.Record(Schema.String, Schema.Unknown)]));

package/dist/Function.d.ts

@@ -1,11 +1,12 @@
 import { CheckpointingOption } from "./internal/checkpoint/Config.js";
 import { EventDefinition, EventType } from "./Event.js";
-import { Duration, Schema } from "effect";
+import { CronDefinition } from "./Cron.js";
+import { Duration } from "effect";
 import { Pipeable } from "effect/Pipeable";
 
 //#region src/Function.d.ts
 declare namespace Function_d_exports {
-  export { BatchEventsOption, CancellationOption, CheckpointingOption, ConcurrencyOption, CronTrigger, DebounceOption, EventSchema, EventTrigger, FunctionOptions, FunctionRegistration, InngestFunction, PriorityOption, RateLimitOption, RegistrationConfig, Retries, SingletonOption, ThrottleOption, TimeoutsOption, Trigger, TriggerInput, TypeId, make };
+  export { BatchEventsOption, CancellationOption, CheckpointingOption, ConcurrencyOption, CronTrigger, DebounceOption, EventSchema, EventTrigger, FunctionOptions, FunctionRegistration, InngestFunction, PriorityOption, RateLimitOption, RegistrationConfig, Retries, SingletonOption, ThrottleOption, TimeoutsOption, Trigger, TriggerDefinition, TriggerInput, TypeId, make };
 }
 /**
  * @since 0.1.0
@@ -29,6 +30,10 @@ interface EventTrigger<E extends EventSchema = EventSchema> {
   readonly event: E;
   readonly if?: string;
 }
+interface NormalizedEventTrigger<E extends EventSchema = EventSchema> {
+  readonly event: E;
+  readonly if?: string;
+}
 /**
  * A cron-based trigger configuration.
  *
@@ -37,6 +42,7 @@ interface EventTrigger<E extends EventSchema = EventSchema> {
  */
 interface CronTrigger {
   readonly cron: string;
+  readonly jitter?: string;
 }
 /**
  * A trigger configuration for a function.
@@ -44,12 +50,14 @@ interface CronTrigger {
  * @since 0.1.0
  * @category triggers
  */
-type Trigger<E extends EventSchema = EventSchema> = EventTrigger<E> | CronTrigger;
+type NormalizedTrigger<E extends EventSchema = EventSchema> = NormalizedEventTrigger<E> | CronTrigger;
+type Trigger<E extends EventSchema = EventSchema> = E | CronDefinition | EventTrigger<E>;
+type TriggerDefinition<E extends EventSchema = EventSchema> = Trigger<E>;
 /**
  * @since 0.1.0
  * @category triggers
  */
-type TriggerInput<E extends EventSchema = EventSchema> = Trigger<E> | ReadonlyArray<Trigger<E>>;
+type TriggerInput<E extends EventSchema = EventSchema> = TriggerDefinition<E> | ReadonlyArray<TriggerDefinition<E>>;
 interface ConcurrencyOption {
   /**
    * The concurrency limit for this option, adding a limit on how many concurrent
@@ -305,6 +313,7 @@ interface FunctionRegistration {
     event?: string;
     cron?: string;
     expression?: string;
+    jitter?: string;
   }>;
   readonly steps: {
     readonly step: {
@@ -378,12 +387,11 @@ interface FunctionRegistration {
  * @since 0.1.0
  * @category models
  */
-interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Codec<unknown, unknown, never, never>, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
+interface InngestFunction<Tag extends string, Triggers extends NormalizedTrigger, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
   readonly [TypeId]: TypeId;
   readonly _tag: Tag;
   readonly key: string;
   readonly triggers: ReadonlyArray<Triggers>;
-  readonly success: Success;
   readonly options: Options;
   readonly toRegistration: (config: RegistrationConfig) => FunctionRegistration;
 }
@@ -392,20 +400,19 @@ interface InngestFunction<Tag extends string, Triggers extends Trigger, Success
  * @category models
  */
 declare namespace InngestFunction {
-  type Any = InngestFunction<string, Trigger, Schema.Codec<any, any, never, never>, FunctionOptions>;
-  type Tag<F> = F extends InngestFunction<infer T, any, any, any> ? T : never;
-  type Triggers<F> = F extends InngestFunction<any, infer T, any, any> ? T : never;
-  type Events<F> = F extends InngestFunction<any, infer T, any, any> ? (T extends EventTrigger<infer E> ? E : never) : never;
+  type Any = InngestFunction<string, NormalizedTrigger, FunctionOptions>;
+  type Tag<F> = F extends InngestFunction<infer T, any, any> ? T : never;
+  type Triggers<F> = F extends InngestFunction<any, infer T, any> ? T : never;
+  type Events<F> = F extends InngestFunction<any, infer T, any> ? (T extends NormalizedEventTrigger<infer E> ? E : never) : never;
   type EventPayload<F> = EventEnvelope<Events<F>>;
   type HasBatchEvents<O> = O extends {
     readonly batchEvents: infer BatchEvents;
   } ? Exclude<BatchEvents, undefined> extends BatchEventsOption ? true : false : false;
   type EventType<F> = HasBatchEvents<Options<F>> extends true ? ReadonlyArray<EventPayload<F>> : EventPayload<F>;
-  type SuccessSchema<F> = F extends InngestFunction<any, any, infer S, any> ? S : never;
-  type Success<F> = Schema.Schema.Type<SuccessSchema<F>>;
-  type Options<F> = F extends InngestFunction<any, any, any, infer O> ? O : never;
+  type Options<F> = F extends InngestFunction<any, any, infer O> ? O : never;
 }
-type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger> ? T[number] : T;
+type NormalizeTrigger<T> = T extends EventSchema ? NormalizedEventTrigger<T> : T extends CronDefinition ? CronTrigger : T extends EventTrigger<infer E> ? NormalizedEventTrigger<E> : T extends CronTrigger ? T : never;
+type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<infer Item> ? NormalizeTrigger<Item> : NormalizeTrigger<T>;
 /**
  * @since 0.1.0
  * @category constructors
@@ -413,35 +420,30 @@ type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger
  * ```ts
  * // Event trigger
  * const Fn1 = InngestFunction.make("Hello", {
- *   trigger: { event: HelloEvent },
- *   success: Schema.Void,
+ *   trigger: HelloEvent,
  * })
  *
  * // Event trigger with CEL filter
  * const Fn2 = InngestFunction.make("Hello", {
  *   trigger: { event: HelloEvent, if: "event.data.name != ''" },
- *   success: Schema.Void,
  * })
  *
  * // Cron trigger
  * const Fn3 = InngestFunction.make("Scheduled", {
- *   trigger: { cron: "0 * * * *" },
- *   success: Schema.Void,
+ *   trigger: InngestCron.make("0 * * * *"),
  * })
  *
  * // Multiple triggers
  * const Fn4 = InngestFunction.make("Multi", {
  *   trigger: [
- *     { event: HelloEvent },
- *     { cron: "0 0 * * *" },
+ *     HelloEvent,
+ *     InngestCron.make("0 0 * * *"),
  *   ],
- *   success: Schema.Void,
  * })
  * ```
  */
-declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Codec<unknown, unknown, never, never>, const O extends FunctionOptions = {}>(tag: Tag, options: {
+declare function make<const Tag extends string, T extends TriggerInput, const O extends FunctionOptions = {}>(tag: Tag, options: {
   readonly trigger: T;
-  readonly success: S;
-} & O): InngestFunction<Tag, NormalizeTriggers<T>, S, O>;
+} & O): InngestFunction<Tag, NormalizeTriggers<T>, O>;
 //#endregion
-export { BatchEventsOption, CancellationOption, type CheckpointingOption, ConcurrencyOption, CronTrigger, DebounceOption, EventSchema, EventTrigger, FunctionOptions, FunctionRegistration, Function_d_exports, InngestFunction, PriorityOption, RateLimitOption, RegistrationConfig, Retries, SingletonOption, ThrottleOption, TimeoutsOption, Trigger, TriggerInput, TypeId, make };
+export { BatchEventsOption, CancellationOption, type CheckpointingOption, ConcurrencyOption, CronTrigger, DebounceOption, EventSchema, EventTrigger, FunctionOptions, FunctionRegistration, Function_d_exports, InngestFunction, PriorityOption, RateLimitOption, RegistrationConfig, Retries, SingletonOption, ThrottleOption, TimeoutsOption, Trigger, TriggerDefinition, TriggerInput, TypeId, make };

package/dist/Function.js

@@ -1,6 +1,8 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { InngestDuration } from "./internal/wire/Duration.js";
 import { resolveConfig, toRegistration } from "./internal/checkpoint/Config.js";
+import { isEventSchema } from "./Event.js";
+import { isCron } from "./Cron.js";
 import { Array, Duration, Option, Predicate, Schema } from "effect";
 import { pipeArguments } from "effect/Pipeable";
 //#region src/Function.ts
@@ -29,7 +31,10 @@ const Proto = {
 			event: t.event.identifier,
 			expression: t.if
 		});
-		else triggers.push({ cron: t.cron });
+		else triggers.push({
+			cron: t.cron,
+			...Predicate.isNotUndefined(t.jitter) ? { jitter: t.jitter } : {}
+		});
 		const opts = this.options;
 		const cancel = opts.cancelOn?.map((c) => ({
 			event: c.event.identifier,
@@ -108,6 +113,14 @@ const Proto = {
 		};
 	}
 };
+const normalizeTrigger = (trigger) => {
+	if (isEventSchema(trigger)) return { event: trigger };
+	if (isCron(trigger)) return {
+		cron: trigger.cron,
+		...Predicate.isNotUndefined(trigger.jitter) ? { jitter: trigger.jitter } : {}
+	};
+	return trigger;
+};
 /**
 * @since 0.1.0
 * @category constructors
@@ -115,29 +128,25 @@ const Proto = {
 * ```ts
 * // Event trigger
 * const Fn1 = InngestFunction.make("Hello", {
-*   trigger: { event: HelloEvent },
-*   success: Schema.Void,
+*   trigger: HelloEvent,
 * })
 *
 * // Event trigger with CEL filter
 * const Fn2 = InngestFunction.make("Hello", {
 *   trigger: { event: HelloEvent, if: "event.data.name != ''" },
-*   success: Schema.Void,
 * })
 *
 * // Cron trigger
 * const Fn3 = InngestFunction.make("Scheduled", {
-*   trigger: { cron: "0 * * * *" },
-*   success: Schema.Void,
+*   trigger: InngestCron.make("0 * * * *"),
 * })
 *
 * // Multiple triggers
 * const Fn4 = InngestFunction.make("Multi", {
 *   trigger: [
-*     { event: HelloEvent },
-*     { cron: "0 0 * * *" },
+*     HelloEvent,
+*     InngestCron.make("0 0 * * *"),
 *   ],
-*   success: Schema.Void,
 * })
 * ```
 */
@@ -145,8 +154,7 @@ function make(tag, options) {
 	const fn = Object.create(Proto);
 	fn._tag = tag;
 	fn.key = `effect-inngest/Function/${tag}`;
-	fn.triggers = Array.ensure(options.trigger);
-	fn.success = options.success;
+	fn.triggers = Array.map(Array.ensure(options.trigger), normalizeTrigger);
 	fn.options = options;
 	return fn;
 }