effect-inngest 0.2.0-beta.0 → 0.3.0-beta.0

package/README.md

@@ -25,14 +25,16 @@
 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 { InngestFunction, InngestGroup, InngestClient } from "effect-inngest";
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
 import { Effect, Schema, Layer } from "effect";
 
-// Define events as TaggedClass
-class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
-  userId: Schema.String,
-  email: Schema.String,
-}) {}
+const UserSignup = InngestEvent.make(
+  "user/signup",
+  Schema.Struct({
+    userId: Schema.String,
+    email: Schema.String,
+  }),
+);
 
 // Create a function — event type is inferred from the trigger
 const ProcessSignup = InngestFunction.make("process-signup", {
@@ -43,17 +45,15 @@ const ProcessSignup = InngestFunction.make("process-signup", {
 // Create group and implement handler
 const Group = InngestGroup.make(ProcessSignup);
 
-class UserOnboarded extends Schema.TaggedClass<UserOnboarded>()("user/onboarded", {
-  userId: Schema.String,
-}) {}
+const UserOnboarded = InngestEvent.make("user/onboarded", Schema.Struct({ userId: Schema.String }));
 
 const Handlers = Group.toLayer({
   "process-signup": ({ event, step }) =>
     Effect.gen(function* () {
-      // event is typed as UserSignup
-      yield* step.run("send-welcome", sendWelcomeEmail(event.email));
+      // 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", new UserOnboarded({ userId: event.userId }));
+      yield* step.sendEvent("notify", UserOnboarded.make({ userId: event.data.userId }));
     }),
 });
 ```
@@ -109,17 +109,18 @@ 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 { InngestFunction, InngestGroup, InngestClient } from "effect-inngest";
-
-// 1. Define your events as TaggedClass
-class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
-  userId: Schema.String,
-  email: Schema.String,
-}) {}
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
+
+// 1. Define your Inngest event definitions
+const UserSignup = InngestEvent.make(
+  "user/signup",
+  Schema.Struct({
+    userId: Schema.String,
+    email: Schema.String,
+  }),
+);
 
-class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcome-sent", {
-  userId: Schema.String,
-}) {}
+const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ userId: Schema.String }));
 
 // 2. Define your functions
 const ProcessSignup = InngestFunction.make("process-signup", {
@@ -138,17 +139,19 @@ const App = InngestGroup.make(ProcessSignup, DailyDigest);
 const Handlers = App.toLayer({
   "process-signup": ({ event, step }) =>
     Effect.gen(function* () {
-      // event is typed as UserSignup
-      yield* Effect.log(`Processing signup for ${event.email}`);
+      // event is typed as { name: "user/signup", data: { userId, email } }
+      yield* Effect.log(`Processing signup for ${event.data.email}`);
 
-      // Durable step - memoized across retries
-      const user = yield* step.run("create-user", Effect.succeed({ id: event.userId, email: event.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 }),
+      });
 
       // Sleep durably
       yield* step.sleep("welcome-delay", Duration.seconds(5));
 
       // Send follow-up event
-      yield* step.sendEvent("notify", new UserWelcomeSent({ userId: user.id }));
+      yield* step.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
 
       return { welcomed: true };
     }),
@@ -197,17 +200,18 @@ 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, InngestFunction, InngestGroup } from "effect-inngest";
+import { InngestClient, InngestEvent, InngestFunction, InngestGroup } from "effect-inngest";
 
 // 1. Define your events
-class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
-  userId: Schema.String,
-  email: Schema.String,
-}) {}
+const UserSignup = InngestEvent.make(
+  "user/signup",
+  Schema.Struct({
+    userId: Schema.String,
+    email: Schema.String,
+  }),
+);
 
-class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcome-sent", {
-  userId: Schema.String,
-}) {}
+const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ userId: Schema.String }));
 
 // 2. Define functions
 const ProcessSignup = InngestFunction.make("process-signup", {
@@ -226,10 +230,12 @@ const App = InngestGroup.make(ProcessSignup, DailyDigest);
 const Handlers = App.toLayer({
   "process-signup": ({ event, step }) =>
     Effect.gen(function* () {
-      yield* Effect.log(`Processing signup for ${event.email}`);
-      const user = yield* step.run("create-user", Effect.succeed({ id: event.userId, email: event.email }));
+      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", new UserWelcomeSent({ userId: user.id }));
+      yield* step.sendEvent("notify", UserWelcomeSent.make({ userId: user.id }));
       return { welcomed: true };
     }),
   "daily-digest": ({ step }) => step.run("send-digest", Effect.log("Sending daily digest...")),
@@ -262,22 +268,31 @@ BunRuntime.runMain(Layer.launch(Server));
 
 ## Getting Started
 
-### 1. Define your events as TaggedClass
+### 1. Define your events
 
 ```typescript
 import { Schema } from "effect";
+import { InngestEvent } from "effect-inngest";
+
+const UserSignup = InngestEvent.make(
+  "user/signup",
+  Schema.Struct({
+    userId: Schema.String,
+    email: Schema.String,
+    plan: Schema.Literal("free", "pro", "enterprise"),
+  }),
+);
+
+const OrderPlaced = InngestEvent.make(
+  "order/placed",
+  Schema.Struct({
+    orderId: Schema.String,
+    items: Schema.Array(Schema.Struct({ sku: Schema.String, qty: Schema.Number })),
+    total: Schema.Number,
+  }),
+);
 
-class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
-  userId: Schema.String,
-  email: Schema.String,
-  plan: Schema.Literal("free", "pro", "enterprise"),
-}) {}
-
-class OrderPlaced extends Schema.TaggedClass<OrderPlaced>()("order/placed", {
-  orderId: Schema.String,
-  items: Schema.Array(Schema.Struct({ sku: Schema.String, qty: Schema.Number })),
-  total: Schema.Number,
-}) {}
+const UserWelcomeSent = InngestEvent.make("user/welcome-sent", Schema.Struct({ userId: Schema.String }));
 ```
 
 ### 2. Define your functions
@@ -311,7 +326,7 @@ const HandlersLive = AppFunctions.toLayer({
     Effect.gen(function* () {
       yield* step.run("create-user", createUser(event));
       yield* step.sleep("delay", Duration.minutes(5));
-      yield* step.sendEvent("welcome", new UserWelcomeSent({ userId: event.userId }));
+      yield* step.sendEvent("welcome", UserWelcomeSent.make({ userId: event.data.userId }));
       return { welcomeEmailSent: true };
     }),
 
@@ -350,8 +365,8 @@ All step operations are durable — they're memoized and survive retries:
 ```typescript
 ({ step }) =>
   Effect.gen(function* () {
-    // Run any Effect with memoization
-    const user = yield* step.run("fetch-user", fetchUser(userId));
+    // Run an Effect with memoization. Value-returning steps require a replay schema.
+    const user = yield* step.run("fetch-user", fetchUser(userId), { schema: User });
 
     // Sleep for a duration
     yield* step.sleep("wait", Duration.hours(24));
@@ -372,7 +387,7 @@ All step operations are durable — they're memoized and survive retries:
     });
 
     // Send events
-    yield* step.sendEvent("notify", new OrderShipped({ orderId }));
+    yield* step.sendEvent("notify", OrderShipped.make({ orderId }));
   });
 ```
 
@@ -384,7 +399,11 @@ Run steps in parallel with Effect's concurrency:
 const [user, orders, prefs] =
   yield *
   Effect.all(
-    [step.run("user", fetchUser(id)), step.run("orders", fetchOrders(id)), step.run("prefs", fetchPreferences(id))],
+    [
+      step.run("user", fetchUser(id), { schema: User }),
+      step.run("orders", fetchOrders(id), { schema: Schema.Array(Order) }),
+      step.run("prefs", fetchPreferences(id), { schema: Preferences }),
+    ],
     { concurrency: "unbounded" },
   );
 ```
@@ -409,7 +428,7 @@ const HandlersLive = AppFunctions.toLayer({
   "process-signup": ({ event, step }) =>
     Effect.gen(function* () {
       const email = yield* EmailService;
-      yield* step.run("send", email.send(event.email, "Welcome!"));
+      yield* step.run("send", email.send(event.data.email, "Welcome!"));
       return { welcomeEmailSent: true };
     }),
 });
@@ -452,13 +471,14 @@ const ProcessOrder = InngestFunction.make("process-order", {
 Control retry behavior with typed errors:
 
 ```typescript
+import { Duration, Effect } from "effect";
 import { NonRetriableError, RetryAfterError } from "effect-inngest";
 
 // Don't retry this error
-yield * new NonRetriableError({ message: "Card permanently declined" });
+yield * Effect.fail(NonRetriableError.make({ message: "Card permanently declined" }));
 
-// Retry after a specific duration (retryAfter in milliseconds)
-yield * new RetryAfterError({ message: "Rate limited", retryAfter: 60000 });
+// Retry after a specific duration
+yield * Effect.fail(RetryAfterError.make({ message: "Rate limited", retryAfter: Duration.seconds(30) }));
 ```
 
 ---
@@ -472,19 +492,21 @@ yield * new RetryAfterError({ message: "Rate limited", retryAfter: 60000 });
 | `InngestFunction`   | Function definition with trigger-based event inference |
 | `InngestGroup`      | Group functions, create handlers, and serve HTTP       |
 | `InngestClient`     | Client configuration and event operations              |
+| `InngestEvent`      | Event schema constructor with typed `.make` envelopes  |
 | `NonRetriableError` | Error to skip retries                                  |
 | `RetryAfterError`   | Error to retry after delay                             |
 
 ### Step Methods
 
-| Method                                     | Description                        |
-| ------------------------------------------ | ---------------------------------- |
-| `step.run(id, effect)`                     | Execute an effect with memoization |
-| `step.sleep(id, duration)`                 | Sleep for a duration               |
-| `step.sleepUntil(id, timestamp)`           | Sleep until a timestamp            |
-| `step.waitForEvent(id, EventSchema, opts)` | Wait for an event with timeout     |
-| `step.invoke(id, opts)`                    | Invoke another function            |
-| `step.sendEvent(id, TaggedEvent)`          | Send events to Inngest             |
+| 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                          |
 
 ---
 

package/dist/Client.d.ts

@@ -1,16 +1,13 @@
+import { CheckpointingOption } from "./internal/checkpoint/Config.js";
+import { CheckpointApiError } from "./internal/checkpoint/Error.js";
 import { GeneratorOpcode } from "./internal/protocol.js";
-import { CheckpointApiError, CheckpointingOption } from "./internal/checkpoint.js";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
+import { Config, Context, Effect, Layer, Schedule, Schema } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import * as Config from "effect/Config";
 import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/Client.d.ts
 declare namespace Client_d_exports {
-  export { CheckpointApiError, CheckpointingOption, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+  export { CheckpointApiError, CheckpointRetrySchedule, CheckpointingOption, ClientConfig, EventPayload, InngestClient, InngestConfig, layer, layerConfig, layerFromEnv };
 }
 /**
  * @since 0.1.0
@@ -91,6 +88,11 @@ interface ClientConfig {
    * The path where the Inngest serve handler is mounted. Used for registration.
    */
   readonly servePath?: string | undefined;
+  /**
+   * The framework adapter serving this app, e.g. "bun" or "nodejs". Used for
+   * protocol headers and registration metadata.
+   */
+  readonly framework?: string | undefined;
   /**
    * Whether to use checkpointing by default for executions of functions
    * created using this client.
@@ -116,7 +118,7 @@ declare const EventPayload: Schema.Struct<{
   readonly v: Schema.optional<Schema.String>;
 }>;
 declare const SendEventResponse: Schema.Struct<{
-  readonly ids: Schema.withDecodingDefault<Schema.$Array<Schema.String>>;
+  readonly ids: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
   readonly status: Schema.optional<Schema.Number>;
 }>;
 type EventPayload = typeof EventPayload.Type;
@@ -148,6 +150,9 @@ interface InngestClientService {
     readonly runId: string;
     readonly fnId: string;
     readonly qiId: string;
+    readonly requestId?: string;
+    readonly generationId?: number;
+    readonly requestStartedAt?: number;
     readonly steps: ReadonlyArray<typeof GeneratorOpcode.Type>;
   }) => Effect.Effect<void, CheckpointApiError>;
 }
@@ -159,6 +164,18 @@ declare const InngestClient_base: Context.ServiceClass<InngestClient, "effect-in
  * @category context
  */
 declare class InngestClient extends InngestClient_base {}
+declare const InngestConfig_base: Context.ServiceClass<InngestConfig, "effect-inngest/InngestConfig", ClientConfig>;
+/**
+ * Static Inngest application configuration.
+ *
+ * This is the narrow dependency for internals that need app settings but not
+ * client behavior such as event sending or checkpoint API calls.
+ *
+ * @since 0.1.0
+ * @category context
+ */
+declare class InngestConfig extends InngestConfig_base {}
+declare const CheckpointRetrySchedule: Context.Reference<Schedule.Schedule<unknown, CheckpointApiError, never, never>>;
 /**
  * Create an InngestClient layer from a config.
  *
@@ -172,14 +189,14 @@ declare class InngestClient extends InngestClient_base {}
  * })
  * ```
  */
-declare const layer: (config: ClientConfig) => Layer.Layer<InngestClient, never, HttpClient.HttpClient>;
+declare const layer: (config: ClientConfig) => Layer.Layer<InngestClient | InngestConfig, never, HttpClient.HttpClient>;
 /**
  * Create an InngestClient layer from Effect Config.
  *
  * @since 0.1.0
  * @category layers
  */
-declare const layerConfig: (config: Config.Wrap<ClientConfig>) => Layer.Layer<InngestClient, Config.ConfigError, HttpClient.HttpClient>;
+declare const layerConfig: (config: Config.Wrap<ClientConfig>) => Layer.Layer<InngestClient | InngestConfig, Config.ConfigError, HttpClient.HttpClient>;
 /**
  * Create an InngestClient layer from environment variables.
  *
@@ -193,6 +210,6 @@ declare const layerConfig: (config: Config.Wrap<ClientConfig>) => Layer.Layer<In
  * @since 0.1.0
  * @category layers
  */
-declare const layerFromEnv: Layer.Layer<InngestClient, Config.ConfigError, HttpClient.HttpClient>;
+declare const layerFromEnv: Layer.Layer<InngestClient | InngestConfig, Config.ConfigError, HttpClient.HttpClient>;
 //#endregion
-export { CheckpointApiError, type CheckpointingOption, Client_d_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+export { CheckpointApiError, CheckpointRetrySchedule, type CheckpointingOption, ClientConfig, Client_d_exports, EventPayload, InngestClient, InngestConfig, layer, layerConfig, layerFromEnv };

package/dist/Client.js

@@ -1,28 +1,21 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { CheckpointApiError } from "./internal/checkpoint.js";
-import { GeneratorOpcode, Headers } from "./internal/protocol.js";
-import { hashSigningKey } from "./internal/signature.js";
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import * as Schema from "effect/Schema";
+import { CheckpointApiError } from "./internal/checkpoint/Error.js";
+import { Headers } from "./internal/protocol.js";
+import { hashSigningKey } from "./internal/serve/Signature.js";
+import { Clock, Config, Context, Effect, Layer, Option, Predicate, Ref, Schedule, Schema } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
-import * as Config from "effect/Config";
-import * as Predicate from "effect/Predicate";
-import * as Schedule from "effect/Schedule";
 //#region src/Client.ts
 /**
 * @since 0.1.0
 */
 var Client_exports = /* @__PURE__ */ __exportAll({
 	CheckpointApiError: () => CheckpointApiError,
+	CheckpointRetrySchedule: () => CheckpointRetrySchedule,
 	EventPayload: () => EventPayload,
 	InngestClient: () => InngestClient,
+	InngestConfig: () => InngestConfig,
 	layer: () => layer,
 	layerConfig: () => layerConfig,
 	layerFromEnv: () => layerFromEnv
@@ -59,15 +52,27 @@ var SendEventError = class extends Schema.TaggedErrorClass()("SendEventError", {
 * @category context
 */
 var InngestClient = class extends Context.Service()("effect-inngest/InngestClient") {};
+/**
+* Static Inngest application configuration.
+*
+* This is the narrow dependency for internals that need app settings but not
+* client behavior such as event sending or checkpoint API calls.
+*
+* @since 0.1.0
+* @category context
+*/
+var InngestConfig = class extends Context.Service()("effect-inngest/InngestConfig") {};
 const resolveMode = (config) => config.mode ?? "dev";
 const resolveEventBaseUrl = (config, mode) => config.eventBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_EVENT_BASE_URL);
 const resolveApiBaseUrl = (config, mode) => config.apiBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_API_BASE_URL);
-const isRetriable = (error) => error.status === void 0 || error.status >= 500;
+const isRetriable = (error) => Predicate.isUndefined(error.status) || error.status >= 500;
 const defaultCheckpointRetrySchedule = Schedule.exponential("100 millis", 2).pipe(Schedule.jittered, Schedule.both(Schedule.recurs(5)), Schedule.while((m) => isRetriable(m.input)));
-const makeClient = (config, httpClient, retrySchedule = defaultCheckpointRetrySchedule) => Effect.gen(function* () {
+const CheckpointRetrySchedule = Context.Reference("effect-inngest/internal/CheckpointRetrySchedule", { defaultValue: () => defaultCheckpointRetrySchedule });
+const makeClient = (config, httpClient) => Effect.gen(function* () {
 	const mode = resolveMode(config);
 	const eventBaseUrl = resolveEventBaseUrl(config, mode);
 	const apiBaseUrl = resolveApiBaseUrl(config, mode);
+	const retrySchedule = yield* CheckpointRetrySchedule;
 	/**
 	* One-way switch: once the fallback signing key succeeds for any
 	* checkpoint API call, all subsequent calls use it first. Per spec
@@ -79,7 +84,7 @@ const makeClient = (config, httpClient, retrySchedule = defaultCheckpointRetrySc
 			message: "Event key is required to send events in cloud mode",
 			events: events.map((e) => e.name)
 		}));
-		const key = config.eventKey ?? "local";
+		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;
@@ -108,14 +113,12 @@ const makeClient = (config, httpClient, retrySchedule = defaultCheckpointRetrySc
 	* error on non-2xx so the caller can decide whether to retry, swap keys,
 	* or fall back.
 	*/
-	const checkpointRequest = (runId, body, signingKey) => {
+	const checkpointRequest = (runId, body, hashedSigningKey) => {
 		const url = new URL(`v1/checkpoint/${runId}/async`, apiBaseUrl).toString();
 		const request = HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders({
 			"Content-Type": "application/json",
-			[Headers.SDK]: `effect-inngest:v${SDK_VERSION}`,
-			[Headers.RequestVersion]: "2",
 			...config.env ? { [Headers.Env]: config.env } : {}
-		}), HttpClientRequest.bearerToken(hashSigningKey(signingKey)), HttpClientRequest.bodyText(body, "application/json"));
+		}), HttpClientRequest.bearerToken(hashedSigningKey), HttpClientRequest.bodyText(body, "application/json"));
 		return httpClient.execute(request).pipe(Effect.scoped, Effect.catch((error) => Effect.fail(new CheckpointApiError({ message: `Network error issuing checkpoint: ${Predicate.hasProperty(error, "message") ? error.message : String(error)}` }))), Effect.flatMap((response) => {
 			if (response.status >= 200 && response.status < 300) return Effect.void;
 			return Effect.fail(new CheckpointApiError({
@@ -126,19 +129,23 @@ const makeClient = (config, httpClient, retrySchedule = defaultCheckpointRetrySc
 	};
 	const checkpointAsync = Effect.fn("InngestClient.checkpointAsync")(function* (args) {
 		const signingKey = config.signingKey;
-		if (!signingKey) return yield* Effect.fail(new CheckpointApiError({ message: "No signing key configured for checkpoint API" }));
+		if (!signingKey && mode !== "dev") return yield* Effect.fail(new CheckpointApiError({ message: "No signing key configured for checkpoint API" }));
 		const now = yield* Clock.currentTimeMillis;
 		const body = JSON.stringify({
 			run_id: args.runId,
 			fn_id: args.fnId,
 			qi_id: args.qiId,
-			steps: Schema.encodeSync(Schema.Array(GeneratorOpcode))(args.steps),
+			request_id: args.requestId,
+			generation_id: args.generationId,
+			request_started_at: args.requestStartedAt,
+			steps: args.steps,
 			ts: now
 		});
 		const fallbackKey = config.signingKeyFallback;
 		return yield* Ref.get(useFallbackKey).pipe(Effect.flatMap((usingFallback) => {
 			const primaryKey = usingFallback && fallbackKey ? fallbackKey : signingKey;
-			return checkpointRequest(args.runId, body, primaryKey).pipe(Effect.catch((error) => error.status === 401 && !usingFallback && fallbackKey ? checkpointRequest(args.runId, body, fallbackKey).pipe(Effect.andThen(Ref.set(useFallbackKey, true))) : Effect.fail(error)));
+			const primaryToken = primaryKey ? hashSigningKey(primaryKey) : "";
+			return checkpointRequest(args.runId, body, primaryToken).pipe(Effect.catch((error) => error.status === 401 && !usingFallback && fallbackKey ? checkpointRequest(args.runId, body, hashSigningKey(fallbackKey)).pipe(Effect.andThen(Ref.set(useFallbackKey, true))) : Effect.fail(error)));
 		})).pipe(Effect.retry(retrySchedule));
 	});
 	return {
@@ -164,21 +171,17 @@ const makeClient = (config, httpClient, retrySchedule = defaultCheckpointRetrySc
 * })
 * ```
 */
-const layer = (config) => Layer.effect(InngestClient, Effect.gen(function* () {
+const layer = (config) => Layer.mergeAll(Layer.succeed(InngestConfig, config), Layer.effect(InngestClient, Effect.gen(function* () {
 	return yield* makeClient(config, yield* HttpClient.HttpClient);
-}));
-const TEST_FACTORY_KEY = Symbol.for("effect-inngest/internal/test-retry-schedule-factory");
-InngestClient[TEST_FACTORY_KEY] = (config, retrySchedule) => Layer.effect(InngestClient, Effect.gen(function* () {
-	return yield* makeClient(config, yield* HttpClient.HttpClient, retrySchedule);
-}));
+})));
 /**
 * Create an InngestClient layer from Effect Config.
 *
 * @since 0.1.0
 * @category layers
 */
-const layerConfig = (config) => Layer.effect(InngestClient, Effect.gen(function* () {
-	return yield* makeClient(yield* Config.unwrap(config), yield* HttpClient.HttpClient);
+const layerConfig = (config) => Layer.unwrap(Effect.gen(function* () {
+	return layer(yield* Config.unwrap(config));
 }));
 /**
 * Create an InngestClient layer from environment variables.
@@ -200,4 +203,4 @@ const layerFromEnv = layerConfig(Config.all({
 	signingKeyFallback: Config.string("INNGEST_SIGNING_KEY_FALLBACK").pipe(Config.option, Config.map(Option.getOrUndefined))
 }));
 //#endregion
-export { CheckpointApiError, Client_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+export { CheckpointApiError, CheckpointRetrySchedule, Client_exports, EventPayload, InngestClient, InngestConfig, layer, layerConfig, layerFromEnv };

package/dist/Event.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+import { MakeOptions } from "effect/Schema";
+
+//#region src/Event.d.ts
+declare namespace Event_d_exports {
+  export { EventData, EventDefinition, EventEnvelope, EventType, isEventSchema, make };
+}
+declare const TypeId: unique symbol;
+interface EventOptions extends MakeOptions {
+  readonly id?: string;
+  readonly ts?: number;
+  readonly v?: string;
+}
+interface EventEnvelope<Name extends string, Data> extends EventOptions {
+  readonly name: Name;
+  readonly data: Data;
+}
+type EventFields<Name extends string, DataSchema extends Schema.Top> = {
+  readonly name: Schema.tag<Name>;
+  readonly data: DataSchema;
+  readonly id: Schema.optional<Schema.String>;
+  readonly ts: Schema.optional<Schema.Number>;
+  readonly v: Schema.optional<Schema.String>;
+};
+type EventStruct<Name extends string, DataSchema extends Schema.Top> = Schema.Struct<EventFields<Name, DataSchema>>;
+type EventConstructor<Name extends string, DataSchema extends Schema.Top> = abstract new (_: never) => EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+type PayloadConstructor<Name extends string, DataSchema extends Schema.Top> = {
+  bivariance(data: Schema.Schema.Type<DataSchema>, options?: EventOptions): EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+}["bivariance"];
+type EventDefinition<Name extends string = string, DataSchema extends Schema.Top = Schema.Top> = EventConstructor<Name, DataSchema> & Omit<Schema.Opaque<EventEnvelope<Name, Schema.Schema.Type<DataSchema>>, EventStruct<Name, DataSchema>, {}>, "make" | "~type.make"> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly identifier: Name;
+  readonly schema: DataSchema;
+  readonly make: unknown extends Schema.Schema.Type<DataSchema> ? (data: never, options?: EventOptions) => EventEnvelope<Name, unknown> : PayloadConstructor<Name, DataSchema>;
+  readonly "~type.make": EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+};
+type EventData<Event extends EventDefinition> = Event extends EventDefinition<any, infer S> ? Schema.Schema.Type<S> : never;
+type EventType<Event extends EventDefinition> = Event extends EventDefinition<infer Name, infer S> ? EventEnvelope<Name, Schema.Schema.Type<S>> : never;
+declare function make<const Name extends string>(name: Name): EventDefinition<Name, Schema.Struct<{}>>;
+declare function make<const Name extends string, const DataSchema extends Schema.Top>(name: Name, schema: DataSchema): EventDefinition<Name, DataSchema>;
+declare const isEventSchema: (value: unknown) => value is EventDefinition;
+//#endregion
+export { EventDefinition, EventType, Event_d_exports };

package/dist/Event.js

@@ -0,0 +1,46 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Predicate, Schema } from "effect";
+//#region src/Event.ts
+/**
+* Public event definitions.
+*
+* Inngest events are protocol-shaped: `{ name, data, id?, ts?, v? }`.
+* The event name is the discriminator; user payload lives under `data`.
+*
+* @since 0.1.0
+*/
+var Event_exports = /* @__PURE__ */ __exportAll({
+	isEventSchema: () => isEventSchema,
+	make: () => make
+});
+const TypeId = Symbol.for("effect-inngest/Event");
+function make(name, schema = Schema.Struct({})) {
+	const fields = {
+		name: Schema.tag(name),
+		data: schema,
+		id: Schema.optional(Schema.String),
+		ts: Schema.optional(Schema.Number),
+		v: Schema.optional(Schema.String)
+	};
+	const Event = Schema.Opaque()(Schema.Struct(fields));
+	class InngestEvent {
+		static [TypeId] = TypeId;
+		static identifier = name;
+		static schema = schema;
+		static make(data, options) {
+			const { id, ts, v } = options ?? {};
+			return {
+				name,
+				data,
+				id,
+				ts,
+				v
+			};
+		}
+	}
+	Object.setPrototypeOf(InngestEvent, Event);
+	return InngestEvent;
+}
+const isEventSchema = (value) => Schema.isSchema(value) && Predicate.hasProperty(value, TypeId);
+//#endregion
+export { Event_exports, make };