effect-inngest 0.1.2 → 0.2.0-beta.0

package/dist/Client.d.ts

@@ -1,14 +1,16 @@
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
+import { GeneratorOpcode } from "./internal/protocol.js";
+import { CheckpointApiError, CheckpointingOption } from "./internal/checkpoint.js";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
+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 ConfigError from "effect/ConfigError";
+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, CheckpointingOption, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
 }
 /**
  * @since 0.1.0
@@ -89,28 +91,40 @@ interface ClientConfig {
    * The path where the Inngest serve handler is mounted. Used for registration.
    */
   readonly servePath?: 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>>;
+  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 +133,25 @@ 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 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.
  *
@@ -148,7 +179,7 @@ declare const layer: (config: ClientConfig) => Layer.Layer<InngestClient, never,
  * @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, Config.ConfigError, HttpClient.HttpClient>;
 /**
  * Create an InngestClient layer from environment variables.
  *
@@ -162,6 +193,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, Config.ConfigError, HttpClient.HttpClient>;
 //#endregion
-export { Client_d_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };
+export { CheckpointApiError, type CheckpointingOption, Client_d_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };

package/dist/Client.js

@@ -1,21 +1,26 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
-import { Headers } from "./internal/protocol.js";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
+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 Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+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,
 	EventPayload: () => EventPayload,
 	InngestClient: () => InngestClient,
 	layer: () => layer,
@@ -40,10 +45,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 +58,31 @@ 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") {};
 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) => error.status === void 0 || 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 mode = resolveMode(config);
 	const eventBaseUrl = resolveEventBaseUrl(config, mode);
 	const apiBaseUrl = resolveApiBaseUrl(config, mode);
-	const sendEvent = (events) => {
-		if (!config.eventKey && mode === "cloud") return new SendEventError({
+	/**
+	* 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 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 +95,62 @@ 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, signingKey) => {
+		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"));
+		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) 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),
+			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)));
+		})).pipe(Effect.retry(retrySchedule));
+	});
 	return {
 		[TypeId]: TypeId,
 		config,
 		mode,
 		eventBaseUrl,
 		apiBaseUrl,
-		sendEvent
+		sendEvent,
+		checkpointAsync
 	};
-};
+});
 /**
 * Create an InngestClient layer from a config.
 *
@@ -112,14 +164,22 @@ const makeClient = (config, httpClient) => {
 * })
 * ```
 */
-const layer = (config) => Layer.effect(InngestClient, Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(config, httpClient)));
+const layer = (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.flatMap(Config.unwrap(config), (resolvedConfig) => Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(resolvedConfig, httpClient))));
+const layerConfig = (config) => Layer.effect(InngestClient, Effect.gen(function* () {
+	return yield* makeClient(yield* Config.unwrap(config), yield* HttpClient.HttpClient);
+}));
 /**
 * Create an InngestClient layer from environment variables.
 *
@@ -139,6 +199,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, Client_exports, EventPayload, InngestClient, layer, layerConfig, layerFromEnv };

package/dist/Events.d.ts

@@ -4,65 +4,46 @@ import * as Schema from "effect/Schema";
 declare namespace Events_d_exports {
   export { FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };
 }
-declare const JsonError_base: Schema.Class<JsonError, {
-  name: typeof Schema.String;
-  message: typeof Schema.String;
-  stack: Schema.optional<typeof Schema.String>;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}, Schema.Struct.Encoded<{
-  name: typeof Schema.String;
-  message: typeof Schema.String;
-  stack: Schema.optional<typeof Schema.String>;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}>, never, {
-  readonly name: string;
-} & {
-  readonly message: string;
-} & {
-  readonly stack?: string | undefined;
-} & {
-  readonly cause?: unknown;
-}, {}, {}>;
+declare const JsonError_base: Schema.Class<JsonError, Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly stack: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, {}>;
 /**
  * Error structure used in internal Inngest events.
  * @since 0.1.0
  */
 declare class JsonError extends JsonError_base {}
-declare const FunctionFailed_base: Schema.TaggedClass<FunctionFailed, "inngest/function.failed", {
-  readonly _tag: Schema.tag<"inngest/function.failed">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  error: typeof JsonError;
-  event: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-}>;
+declare const FunctionFailed_base: Schema.Class<FunctionFailed, Schema.TaggedStruct<"inngest/function.failed", {
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly error: typeof JsonError;
+  readonly event: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, {}>;
 /**
  * Sent when a function fails after exhausting all retries.
  * Trigger on this to handle failures (e.g., alerting, cleanup).
  * @since 0.1.0
  */
 declare class FunctionFailed extends FunctionFailed_base {}
-declare const FunctionFinishedError_base: Schema.TaggedClass<FunctionFinishedError, "inngest/function.finished", {
-  readonly _tag: Schema.tag<"inngest/function.finished">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-  error: typeof JsonError;
-}>;
+declare const FunctionFinishedError_base: Schema.Class<FunctionFinishedError, Schema.TaggedStruct<"inngest/function.finished", {
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly error: typeof JsonError;
+}>, {}>;
 /**
  * Sent when a function finishes with an error.
  * @since 0.1.0
  */
 declare class FunctionFinishedError extends FunctionFinishedError_base {}
-declare const FunctionFinishedSuccess_base: Schema.TaggedClass<FunctionFinishedSuccess, "inngest/function.finished", {
-  readonly _tag: Schema.tag<"inngest/function.finished">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-  result: typeof Schema.Unknown;
-}>;
+declare const FunctionFinishedSuccess_base: Schema.Class<FunctionFinishedSuccess, Schema.TaggedStruct<"inngest/function.finished", {
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly result: Schema.Unknown;
+}>, {}>;
 /**
  * Sent when a function finishes successfully.
  * @since 0.1.0
@@ -72,35 +53,29 @@ declare class FunctionFinishedSuccess extends FunctionFinishedSuccess_base {}
  * Union of both FunctionFinished variants.
  * @since 0.1.0
  */
-declare const FunctionFinished: Schema.Union<[typeof FunctionFinishedError, typeof FunctionFinishedSuccess]>;
+declare const FunctionFinished: Schema.Union<readonly [typeof FunctionFinishedError, typeof FunctionFinishedSuccess]>;
 type FunctionFinished = typeof FunctionFinished.Type;
-declare const FunctionCancelled_base: Schema.TaggedClass<FunctionCancelled, "inngest/function.cancelled", {
-  readonly _tag: Schema.tag<"inngest/function.cancelled">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-}>;
+declare const FunctionCancelled_base: Schema.Class<FunctionCancelled, Schema.TaggedStruct<"inngest/function.cancelled", {
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+}>, {}>;
 /**
  * Sent when a function is cancelled.
  * @since 0.1.0
  */
 declare class FunctionCancelled extends FunctionCancelled_base {}
-declare const FunctionInvoked_base: Schema.TaggedClass<FunctionInvoked, "inngest/function.invoked", {
-  readonly _tag: Schema.tag<"inngest/function.invoked">;
-} & {
-  data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-}>;
+declare const FunctionInvoked_base: Schema.Class<FunctionInvoked, Schema.TaggedStruct<"inngest/function.invoked", {
+  readonly data: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
 /**
  * Sent when a function is invoked via step.invoke().
  * @since 0.1.0
  */
 declare class FunctionInvoked extends FunctionInvoked_base {}
-declare const ScheduledTimer_base: Schema.TaggedClass<ScheduledTimer, "inngest/scheduled.timer", {
-  readonly _tag: Schema.tag<"inngest/scheduled.timer">;
-} & {
-  cron: typeof Schema.String;
-}>;
+declare const ScheduledTimer_base: Schema.Class<ScheduledTimer, Schema.TaggedStruct<"inngest/scheduled.timer", {
+  readonly cron: Schema.String;
+}>, {}>;
 /**
  * Sent when a cron trigger fires.
  * @since 0.1.0

package/dist/Events.js

@@ -1,6 +1,5 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import * as Schema from "effect/Schema";
-
 //#region src/Events.ts
 /**
 * Internal Inngest events that the platform sends automatically.
@@ -36,10 +35,7 @@ var FunctionFailed = class extends Schema.TaggedClass()("inngest/function.failed
 	function_id: Schema.String,
 	run_id: Schema.String,
 	error: JsonError,
-	event: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})
+	event: Schema.Record(Schema.String, Schema.Unknown)
 }) {};
 /**
 * Sent when a function finishes with an error.
@@ -65,7 +61,7 @@ var FunctionFinishedSuccess = class extends Schema.TaggedClass()("inngest/functi
 * Union of both FunctionFinished variants.
 * @since 0.1.0
 */
-const FunctionFinished = Schema.Union(FunctionFinishedError, FunctionFinishedSuccess);
+const FunctionFinished = Schema.Union([FunctionFinishedError, FunctionFinishedSuccess]);
 /**
 * Sent when a function is cancelled.
 * @since 0.1.0
@@ -79,15 +75,11 @@ var FunctionCancelled = class extends Schema.TaggedClass()("inngest/function.can
 * Sent when a function is invoked via step.invoke().
 * @since 0.1.0
 */
-var FunctionInvoked = class extends Schema.TaggedClass()("inngest/function.invoked", { data: Schema.optional(Schema.Record({
-	key: Schema.String,
-	value: Schema.Unknown
-})) }) {};
+var FunctionInvoked = class extends Schema.TaggedClass()("inngest/function.invoked", { data: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)) }) {};
 /**
 * Sent when a cron trigger fires.
 * @since 0.1.0
 */
 var ScheduledTimer = class extends Schema.TaggedClass()("inngest/scheduled.timer", { cron: Schema.String }) {};
-
 //#endregion
-export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };
+export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Function.d.ts

@@ -1,8 +1,10 @@
+import { CheckpointingOption } from "./internal/checkpoint.js";
 import { Duration, Schema } from "effect";
+import { Pipeable } from "effect/Pipeable";
 
 //#region src/Function.d.ts
 declare namespace Function_d_exports {
-  export { CronTrigger, EventTrigger, FunctionOptions, InngestFunction, Trigger, TriggerInput, TypeId, make };
+  export { CheckpointingOption, CronTrigger, EventTrigger, FunctionOptions, InngestFunction, Trigger, TriggerInput, TypeId, make };
 }
 /**
  * @since 0.1.0
@@ -14,8 +16,8 @@ declare const TypeId: unique symbol;
  * @category type ids
  */
 type TypeId = typeof TypeId;
-type EventSchema = Schema.Schema.Any & {
-  readonly _tag: string;
+type EventSchema = Schema.Top & {
+  readonly identifier: string;
 };
 /**
  * An event-based trigger configuration.
@@ -88,7 +90,7 @@ interface RateLimitOption {
   /**
    * The period of time to allow the function to run `limit` times.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
 }
 interface ThrottleOption {
   /**
@@ -106,7 +108,7 @@ interface ThrottleOption {
    * The period of time for the rate limit. Run starts are evenly spaced through
    * the given period. The minimum granularity is 1 second.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
   /**
    * The number of runs allowed to start in the given window in a single burst.
    * A burst > 1 bypasses smoothing for the burst and allows many runs to start
@@ -122,13 +124,13 @@ interface DebounceOption {
   /**
    * The period of time to delay after receiving the last trigger to run the function.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
   /**
    * The maximum time that a debounce can be extended before running.
    * If events are continually received within the given period, a function
    * will always run after the given timeout period.
    */
-  readonly timeout?: Duration.DurationInput;
+  readonly timeout?: Duration.Input;
 }
 interface BatchEventsOption {
   /**
@@ -140,7 +142,7 @@ interface BatchEventsOption {
    * If timeout is reached, the function will be invoked with a batch
    * even if it's not filled up to `maxSize`.
    */
-  readonly timeout: Duration.DurationInput;
+  readonly timeout: Duration.Input;
   /**
    * An optional key to use for batching.
    */
@@ -169,13 +171,13 @@ interface TimeoutsOption {
    * This is, essentially, the amount of time that a function sits in the
    * queue before starting.
    */
-  readonly start?: Duration.DurationInput;
+  readonly start?: Duration.Input;
   /**
    * Finish represents the time between a function starting and the function
    * finishing. If a function takes longer than this time to finish, the
    * function is marked as cancelled.
    */
-  readonly finish?: Duration.DurationInput;
+  readonly finish?: Duration.Input;
 }
 interface SingletonOption {
   /**
@@ -208,7 +210,7 @@ interface CancellationOption {
    * specified, cancellation triggers are valid for up to a year or until the
    * function ends.
    */
-  readonly timeout?: Duration.DurationInput;
+  readonly timeout?: Duration.Input;
 }
 type Retries = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
 /**
@@ -278,6 +280,19 @@ interface FunctionOptions {
    * Batch events configuration.
    */
   readonly batchEvents?: BatchEventsOption;
+  /**
+   * Whether to use checkpointing for executions of this function. Overrides
+   * the client-level `checkpointing` setting.
+   *
+   * - `false` disables checkpointing for this function.
+   * - `true` enables checkpointing with safe defaults
+   *   (`bufferedSteps: 1`, `maxInterval: 0`, `maxRuntime: 10s`).
+   * - An object lets you tune `bufferedSteps`, `maxInterval`, `maxRuntime`.
+   *
+   * Defaults to inheriting from the client-level setting (which itself
+   * defaults to enabled with safe defaults).
+   */
+  readonly checkpointing?: CheckpointingOption;
 }
 interface RegistrationConfig {
   readonly appId: string;
@@ -347,6 +362,11 @@ interface FunctionRegistration {
     readonly key?: string;
   };
   readonly idempotency?: string;
+  readonly checkpoint?: {
+    readonly batch_steps: number;
+    readonly batch_interval: string;
+    readonly max_runtime: string;
+  };
 }
 /**
  * An Inngest function definition.
@@ -354,7 +374,7 @@ interface FunctionRegistration {
  * @since 0.1.0
  * @category models
  */
-interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Schema.Any, Options extends FunctionOptions = FunctionOptions> {
+interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Top, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
   readonly [TypeId]: TypeId;
   readonly _tag: Tag;
   readonly key: string;
@@ -368,7 +388,7 @@ interface InngestFunction<Tag extends string, Triggers extends Trigger, Success
  * @category models
  */
 declare namespace InngestFunction {
-  type Any = InngestFunction<string, Trigger, Schema.Schema.Any, FunctionOptions>;
+  type Any = InngestFunction<string, Trigger, Schema.Top, 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;
@@ -410,9 +430,9 @@ type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger
  * })
  * ```
  */
-declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Schema.Any, const O extends FunctionOptions = {}>(tag: Tag, options: {
+declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Top, const O extends FunctionOptions = {}>(tag: Tag, options: {
   readonly trigger: T;
   readonly success: S;
 } & O): InngestFunction<Tag, NormalizeTriggers<T>, S, O>;
 //#endregion
-export { CronTrigger, EventTrigger, FunctionOptions, Function_d_exports, InngestFunction, Trigger, TriggerInput, TypeId, make };
+export { type CheckpointingOption, CronTrigger, EventTrigger, FunctionOptions, Function_d_exports, InngestFunction, Trigger, TriggerInput, TypeId, make };