effect-inngest 0.1.3 → 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,14 +1,13 @@
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Schema from "effect/Schema";
-import * as Config from "effect/Config";
-import * as ConfigError from "effect/ConfigError";
+import { CheckpointingOption } from "./internal/checkpoint/Config.js";
+import { CheckpointApiError } from "./internal/checkpoint/Error.js";
+import { GeneratorOpcode } from "./internal/protocol.js";
+import { Config, Context, Effect, Layer, Schedule, Schema } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/Client.d.ts
 declare namespace Client_d_exports {
-  export { EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+  export { CheckpointApiError, CheckpointRetrySchedule, CheckpointingOption, ClientConfig, EventPayload, InngestClient, InngestConfig, layer, layerConfig, layerFromEnv };
 }
 /**
  * @since 0.1.0
@@ -89,28 +88,45 @@ 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.
+   *
+   * - `false` disables checkpointing for all functions on this client.
+   * - `true` enables checkpointing with safe defaults (`bufferedSteps: 1`,
+   *   `maxInterval: 0`, `maxRuntime: 10s`). Steps are checkpointed to the
+   *   Inngest API as they complete instead of yielding a 206 per step.
+   * - An object lets you tune `bufferedSteps`, `maxInterval`, `maxRuntime`.
+   *
+   * Per-function `checkpointing` overrides this setting. Defaults to `true`
+   * (checkpointing enabled).
+   *
+   * @default true
+   */
+  readonly checkpointing?: CheckpointingOption | undefined;
 }
 declare const EventPayload: Schema.Struct<{
-  name: typeof Schema.String;
-  data: typeof Schema.Unknown;
-  ts: Schema.optional<typeof Schema.Number>;
-  id: Schema.optional<typeof Schema.String>;
-  v: Schema.optional<typeof Schema.String>;
+  readonly name: Schema.String;
+  readonly data: Schema.Unknown;
+  readonly ts: Schema.optional<Schema.Number>;
+  readonly id: Schema.optional<Schema.String>;
+  readonly v: Schema.optional<Schema.String>;
 }>;
 declare const SendEventResponse: Schema.Struct<{
-  ids: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-    default: () => never[];
-  }>;
-  status: Schema.optional<typeof Schema.Number>;
+  readonly ids: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+  readonly status: Schema.optional<Schema.Number>;
 }>;
 type EventPayload = typeof EventPayload.Type;
 type SendEventResponse = typeof SendEventResponse.Type;
-declare const SendEventError_base: Schema.TaggedErrorClass<SendEventError, "SendEventError", {
-  readonly _tag: Schema.tag<"SendEventError">;
-} & {
-  message: typeof Schema.String;
-  events: Schema.Array$<typeof Schema.String>;
-}>;
+declare const SendEventError_base: Schema.Class<SendEventError, Schema.TaggedStruct<"SendEventError", {
+  readonly message: Schema.String;
+  readonly events: Schema.$Array<Schema.String>;
+}>, _$effect_Cause0.YieldableError>;
 declare class SendEventError extends SendEventError_base {}
 interface InngestClientService {
   readonly [TypeId]: TypeId;
@@ -119,8 +135,28 @@ interface InngestClientService {
   readonly eventBaseUrl: string;
   readonly apiBaseUrl: string;
   readonly sendEvent: (events: ReadonlyArray<EventPayload>) => Effect.Effect<SendEventResponse, SendEventError>;
+  /**
+   * Async checkpoint API call per spec §10.3.1.
+   *
+   * POSTs `{run_id, fn_id, qi_id, steps, ts}` to
+   * `{apiBaseUrl}/v1/checkpoint/{runId}/async` with a hashed-signing-key
+   * Bearer token. Retries 5xx responses with exponential backoff + jitter
+   * (5 attempts). On 401, falls back to the configured fallback signing key
+   * for the remainder of the client's lifetime (one-way switch).
+   *
+   * @internal
+   */
+  readonly checkpointAsync: (args: {
+    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>;
 }
-declare const InngestClient_base: Context.TagClass<InngestClient, "effect-inngest/InngestClient", InngestClientService>;
+declare const InngestClient_base: Context.ServiceClass<InngestClient, "effect-inngest/InngestClient", InngestClientService>;
 /**
  * InngestClient service for communicating with Inngest.
  *
@@ -128,6 +164,18 @@ declare const InngestClient_base: Context.TagClass<InngestClient, "effect-innges
  * @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.
  *
@@ -141,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.Config.Wrap<ClientConfig>) => Layer.Layer<InngestClient, ConfigError.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.
  *
@@ -162,6 +210,6 @@ declare const layerConfig: (config: Config.Config.Wrap<ClientConfig>) => Layer.L
  * @since 0.1.0
  * @category layers
  */
-declare const layerFromEnv: Layer.Layer<InngestClient, ConfigError.ConfigError, HttpClient.HttpClient>;
+declare const layerFromEnv: Layer.Layer<InngestClient | InngestConfig, Config.ConfigError, HttpClient.HttpClient>;
 //#endregion
-export { 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,23 +1,21 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { CheckpointApiError } from "./internal/checkpoint/Error.js";
 import { Headers } from "./internal/protocol.js";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Config from "effect/Config";
-import * as Predicate from "effect/Predicate";
-
+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 HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 //#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
@@ -40,10 +38,10 @@ const EventPayload = Schema.Struct({
 	v: Schema.optional(Schema.String)
 });
 const SendEventResponse = Schema.Struct({
-	ids: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
+	ids: Schema.Array(Schema.String).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
 	status: Schema.optional(Schema.Number)
 });
-var SendEventError = class extends Schema.TaggedError()("SendEventError", {
+var SendEventError = class extends Schema.TaggedErrorClass()("SendEventError", {
 	message: Schema.String,
 	events: Schema.Array(Schema.String)
 }) {};
@@ -53,23 +51,43 @@ var SendEventError = class extends Schema.TaggedError()("SendEventError", {
 * @since 0.1.0
 * @category context
 */
-var InngestClient = class extends Context.Tag("effect-inngest/InngestClient")() {};
+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 makeClient = (config, httpClient) => {
+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 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 sendEvent = (events) => {
-		if (!config.eventKey && mode === "cloud") return new SendEventError({
+	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
+	* §10.3.4.
+	*/
+	const useFallbackKey = yield* Ref.make(false);
+	const sendEvent = Effect.fn("InngestClient.sendEvent")(function* (events) {
+		if (!config.eventKey && mode === "cloud") return yield* Effect.fail(new SendEventError({
 			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 = Date.now();
+		const now = yield* Clock.currentTimeMillis;
 		const payloads = events.map((e) => ({
 			name: e.name,
 			data: e.data ?? {},
@@ -82,23 +100,64 @@ const makeClient = (config, httpClient) => {
 			[Headers.SDK]: `effect-ts:v${SDK_VERSION}`,
 			...config.env ? { [Headers.Env]: config.env } : {}
 		}));
-		return HttpClientRequest.schemaBodyJson(Schema.Array(EventPayload))(request, payloads).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(SendEventResponse)), Effect.map((response) => ({
+		return yield* HttpClientRequest.schemaBodyJson(Schema.Array(EventPayload))(request, payloads).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(SendEventResponse)), Effect.map((response) => ({
 			ids: response.ids,
 			status: response.status
-		})), Effect.scoped, Effect.catchAll((error) => new SendEventError({
+		})), Effect.scoped, Effect.catch((error) => Effect.fail(new SendEventError({
 			message: `Failed to send events: ${Predicate.hasProperty(error, "message") ? error.message : "Unknown error"}`,
 			events: eventNames
-		})));
+		}))));
+	});
+	/**
+	* Issue a checkpoint POST with the given signing key. Returns a tagged
+	* error on non-2xx so the caller can decide whether to retry, swap keys,
+	* or fall back.
+	*/
+	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",
+			...config.env ? { [Headers.Env]: config.env } : {}
+		}), 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({
+				message: `Checkpoint API returned ${response.status}`,
+				status: response.status
+			}));
+		}));
 	};
+	const checkpointAsync = Effect.fn("InngestClient.checkpointAsync")(function* (args) {
+		const signingKey = config.signingKey;
+		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,
+			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;
+			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 {
 		[TypeId]: TypeId,
 		config,
 		mode,
 		eventBaseUrl,
 		apiBaseUrl,
-		sendEvent
+		sendEvent,
+		checkpointAsync
 	};
-};
+});
 /**
 * Create an InngestClient layer from a config.
 *
@@ -112,14 +171,18 @@ const makeClient = (config, httpClient) => {
 * })
 * ```
 */
-const layer = (config) => Layer.effect(InngestClient, Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(config, httpClient)));
+const layer = (config) => Layer.mergeAll(Layer.succeed(InngestConfig, config), Layer.effect(InngestClient, Effect.gen(function* () {
+	return yield* makeClient(config, yield* HttpClient.HttpClient);
+})));
 /**
 * Create an InngestClient layer from Effect Config.
 *
 * @since 0.1.0
 * @category layers
 */
-const layerConfig = (config) => Layer.effect(InngestClient, Effect.flatMap(Config.unwrap(config), (resolvedConfig) => Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(resolvedConfig, httpClient))));
+const layerConfig = (config) => Layer.unwrap(Effect.gen(function* () {
+	return layer(yield* Config.unwrap(config));
+}));
 /**
 * Create an InngestClient layer from environment variables.
 *
@@ -139,6 +202,5 @@ const layerFromEnv = layerConfig(Config.all({
 	signingKey: Config.string("INNGEST_SIGNING_KEY").pipe(Config.option, Config.map(Option.getOrUndefined)),
 	signingKeyFallback: Config.string("INNGEST_SIGNING_KEY_FALLBACK").pipe(Config.option, Config.map(Option.getOrUndefined))
 }));
-
 //#endregion
-export { Client_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+export { CheckpointApiError, CheckpointRetrySchedule, Client_exports, EventPayload, InngestClient, InngestConfig, layer, layerConfig, layerFromEnv };