effect-inngest 0.1.2 → 0.2.0-beta.0

package/dist/Function.js

@@ -1,7 +1,8 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { timeStr } from "./internal/helpers.js";
-import { Array, Duration, Predicate, Schema } from "effect";
-
+import { resolveConfig, toRegistration } from "./internal/checkpoint.js";
+import { Array, Predicate } from "effect";
+import { pipeArguments } from "effect/Pipeable";
 //#region src/Function.ts
 /**
 * @since 0.1.0
@@ -18,10 +19,13 @@ const TypeId = Symbol.for("effect-inngest/Function");
 const isEventTrigger = (t) => Predicate.hasProperty(t, "event");
 const Proto = {
 	[TypeId]: TypeId,
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
 	toRegistration(config) {
 		const triggers = [];
 		for (const t of this.triggers) if (isEventTrigger(t)) triggers.push({
-			event: t.event._tag,
+			event: t.event.identifier,
 			expression: t.if
 		});
 		else triggers.push({ cron: t.cron });
@@ -51,7 +55,7 @@ const Proto = {
 			period: timeStr(opts.debounce.period),
 			timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : void 0
 		} : void 0;
-		const concurrency = opts.concurrency != null ? typeof opts.concurrency === "number" ? [{ limit: opts.concurrency }] : Array.ensure(opts.concurrency).map((c) => ({
+		const concurrency = opts.concurrency != null ? Predicate.isNumber(opts.concurrency) ? [{ limit: opts.concurrency }] : Array.ensure(opts.concurrency).map((c) => ({
 			key: c.key,
 			limit: c.limit,
 			scope: c.scope
@@ -67,6 +71,8 @@ const Proto = {
 			key: opts.batchEvents.key
 		} : void 0;
 		const idempotency = opts.idempotency;
+		const resolvedCheckpoint = opts.checkpointing !== void 0 ? resolveConfig(opts.checkpointing, void 0) : void 0;
+		const checkpoint = resolvedCheckpoint ? toRegistration(resolvedCheckpoint) : void 0;
 		const fnId = `${config.appId}-${this._tag}`;
 		const stepUrl = new URL(config.url);
 		stepUrl.searchParams.set("fnId", fnId);
@@ -93,7 +99,8 @@ const Proto = {
 			priority,
 			singleton,
 			batchEvents,
-			idempotency
+			idempotency,
+			checkpoint
 		};
 	}
 };
@@ -139,6 +146,5 @@ function make(tag, options) {
 	fn.options = options;
 	return fn;
 }
-
 //#endregion
-export { Function_exports, TypeId, make };
+export { Function_exports, TypeId, make };

package/dist/Group.d.ts

@@ -1,10 +1,11 @@
 import { InngestClient } from "./Client.js";
 import { InngestFunction } from "./Function.js";
 import { HandlerContext } from "./internal/step.js";
-import * as HttpApp from "@effect/platform/HttpApp";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 
 //#region src/Group.d.ts
@@ -116,7 +117,7 @@ declare const make: <Fns extends ReadonlyArray<InngestFunction.Any>>(...fns: Fns
  * )
  * ```
  */
-declare const toHttpApp: (group: InngestGroup.Any) => HttpApp.Default<never, InngestClient | HttpClient.HttpClient>;
+declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, InngestClient | HttpClient.HttpClient | HttpServerRequest.HttpServerRequest>;
 /**
  * Create a standalone web handler from an InngestGroup.
  *

package/dist/Group.js

@@ -1,22 +1,19 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Headers } from "./internal/protocol.js";
 import { SignatureLive } from "./internal/signature.js";
+import "./internal/step.js";
 import { handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody } from "./internal/handler.js";
-import * as HttpApp from "@effect/platform/HttpApp";
-import "@effect/platform/HttpClient";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as UrlParams from "@effect/platform/UrlParams";
-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 "effect/unstable/http/HttpClient";
+import * as HttpEffect from "effect/unstable/http/HttpEffect";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 //#region src/Group.ts
-/**
-* @since 0.1.0
-*/
 var Group_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
 	make: () => make,
@@ -42,7 +39,7 @@ const Proto = {
 					context
 				});
 			}
-			return Context.unsafeMake(contextMap);
+			return Context.makeUnsafe(contextMap);
 		}));
 	},
 	toLayerHandler(tag, handler) {
@@ -54,7 +51,7 @@ const Proto = {
 				handler,
 				context
 			});
-			return Context.unsafeMake(contextMap);
+			return Context.makeUnsafe(contextMap);
 		}));
 	}
 };
@@ -88,7 +85,7 @@ const make = (...fns) => {
 * )
 * ```
 */
-const toHttpApp = (group) => Effect.gen(function* () {
+const toHttpApp = Effect.fn("InngestGroup.toHttpApp")(function* (group) {
 	const request = yield* HttpServerRequest.HttpServerRequest;
 	const method = request.method;
 	const requestUrl = Option.match(HttpServerRequest.toURL(request), {
@@ -110,16 +107,22 @@ const toHttpApp = (group) => Effect.gen(function* () {
 		});
 	}
 	if (method === "POST") {
-		const url = Option.getOrThrow(HttpServerRequest.toURL(request));
-		const ExecuteParams = Schema.Struct({
+		const url = yield* Option.match(HttpServerRequest.toURL(request), {
+			onNone: () => Effect.fail(HttpServerResponse.jsonUnsafe({ error: "Unable to parse request URL" }, {
+				status: 400,
+				headers: { [Headers.NoRetry]: "true" }
+			})),
+			onSome: (u) => Effect.succeed(u)
+		});
+		const ExecuteParamsSchema = UrlParams.schemaRecord.pipe(Schema.decodeTo(Schema.Struct({
 			fnId: Schema.String,
 			stepId: Schema.optional(Schema.String)
-		});
-		const params = yield* UrlParams.schemaStruct(ExecuteParams)(UrlParams.fromInput(url.searchParams)).pipe(Effect.catchAll(() => Effect.fail(HttpServerResponse.unsafeJson({ error: "Missing or invalid fnId query parameter" }, {
+		})));
+		const params = yield* Schema.decodeUnknownEffect(ExecuteParamsSchema)(UrlParams.fromInput(url.searchParams)).pipe(Effect.catch(() => Effect.fail(HttpServerResponse.jsonUnsafe({ error: "Missing or invalid fnId query parameter" }, {
 			status: 400,
 			headers: { [Headers.NoRetry]: "true" }
 		}))));
-		const body = yield* verifyAndParseRequestBody(request).pipe(Effect.provide(SignatureLive), Effect.catchAll((error) => Effect.fail(HttpServerResponse.unsafeJson({ error: error.message }, {
+		const body = yield* verifyAndParseRequestBody(request).pipe(Effect.provide(SignatureLive), Effect.catch((error) => Effect.fail(HttpServerResponse.jsonUnsafe({ error: error.message }, {
 			status: error._tag === "SignatureError" ? 401 : 400,
 			headers: { [Headers.NoRetry]: "true" }
 		}))));
@@ -130,7 +133,7 @@ const toHttpApp = (group) => Effect.gen(function* () {
 		});
 	}
 	return yield* HttpServerResponse.json({ error: `Method ${method} not allowed` }, { status: 405 });
-}).pipe(Effect.catchAllCause((cause) => HttpServerResponse.json({
+}, Effect.catchCause((cause) => HttpServerResponse.json({
 	error: "Internal server error",
 	cause: String(cause)
 }, { status: 500 }).pipe(Effect.orDie)));
@@ -158,7 +161,6 @@ const toHttpApp = (group) => Effect.gen(function* () {
 * process.on("SIGTERM", dispose)
 * ```
 */
-const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));
-
+const toWebHandler = (group, options) => HttpEffect.toWebHandlerLayer(toHttpApp(group), options.layer);
 //#endregion
-export { Group_exports, TypeId, make, toHttpApp, toWebHandler };
+export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/dist/HttpApi.d.ts

@@ -2,74 +2,69 @@ import { InngestClient } from "./Client.js";
 import { InngestGroup } from "./Group.js";
 import { SignatureError } from "./internal/signature.js";
 import { InvalidRequestError } from "./internal/handler.js";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
-import * as HttpApi from "@effect/platform/HttpApi";
-import * as HttpApiEndpoint from "@effect/platform/HttpApiEndpoint";
-import * as HttpApiGroup from "@effect/platform/HttpApiGroup";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Layer from "effect/Layer";
+import * as _$effect_Cause0 from "effect/Cause";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
 
 //#region src/HttpApi.d.ts
 declare namespace HttpApi_d_exports {
   export { InngestApiGroup, layerGroup };
 }
-declare const FunctionNotFoundError_base: Schema.TaggedErrorClass<FunctionNotFoundError, "FunctionNotFoundError", {
-  readonly _tag: Schema.tag<"FunctionNotFoundError">;
-} & {
-  message: typeof Schema.String;
-}>;
+declare const FunctionNotFoundError_base: Schema.Class<FunctionNotFoundError, Schema.TaggedStruct<"FunctionNotFoundError", {
+  readonly message: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
 declare class FunctionNotFoundError extends FunctionNotFoundError_base {}
+declare const InngestApiGroup_base: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpoint.HttpApiEndpoint<"introspect", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Union<readonly [Schema.Struct<{
+  readonly function_count: Schema.Number;
+  readonly has_event_key: Schema.Boolean;
+  readonly has_signing_key: Schema.Boolean;
+  readonly has_signing_key_fallback: Schema.Boolean;
+  readonly mode: Schema.Literals<readonly ["cloud", "dev"]>;
+  readonly schema_version: Schema.Literal<"2024-05-24">;
+  readonly extra: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly authentication_succeeded: Schema.Literal<true>;
+  readonly api_origin: Schema.String;
+  readonly app_id: Schema.String;
+  readonly env: Schema.NullOr<Schema.String>;
+  readonly event_api_origin: Schema.String;
+  readonly event_key_hash: Schema.NullOr<Schema.String>;
+  readonly framework: Schema.String;
+  readonly sdk_language: Schema.String;
+  readonly sdk_version: Schema.String;
+  readonly serve_origin: Schema.NullOr<Schema.String>;
+  readonly serve_path: Schema.NullOr<Schema.String>;
+  readonly signing_key_fallback_hash: Schema.NullOr<Schema.String>;
+  readonly signing_key_hash: Schema.NullOr<Schema.String>;
+}>, Schema.Struct<{
+  readonly function_count: Schema.Number;
+  readonly has_event_key: Schema.Boolean;
+  readonly has_signing_key: Schema.Boolean;
+  readonly has_signing_key_fallback: Schema.Boolean;
+  readonly mode: Schema.Literals<readonly ["cloud", "dev"]>;
+  readonly schema_version: Schema.Literal<"2024-05-24">;
+  readonly extra: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly authentication_succeeded: Schema.Union<readonly [Schema.Literal<false>, Schema.Null]>;
+  readonly functions: Schema.optionalKey<Schema.$Array<Schema.Unknown>>;
+}>]>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+  readonly message: Schema.String;
+  readonly modified: Schema.Boolean;
+}>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+  readonly fnId: Schema.String;
+  readonly stepId: Schema.optional<Schema.String>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Unknown>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never>, false>;
 /**
  * @since 0.1.0
  * @category api
  */
-declare const InngestApiGroup: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpoint.HttpApiEndpoint<"introspect", "GET", never, never, never, never, ({
-  readonly function_count: number;
-  readonly has_event_key: boolean;
-  readonly has_signing_key: boolean;
-  readonly has_signing_key_fallback: boolean;
-  readonly mode: "cloud" | "dev";
-  readonly schema_version: "2024-05-24";
-  readonly extra?: {
-    readonly [x: string]: unknown;
-  } | undefined;
-} & {
-  readonly authentication_succeeded: true;
-  readonly api_origin: string;
-  readonly app_id: string;
-  readonly env: string | null;
-  readonly event_api_origin: string;
-  readonly event_key_hash: string | null;
-  readonly framework: string;
-  readonly sdk_language: string;
-  readonly sdk_version: string;
-  readonly serve_origin: string | null;
-  readonly serve_path: string | null;
-  readonly signing_key_fallback_hash: string | null;
-  readonly signing_key_hash: string | null;
-}) | ({
-  readonly function_count: number;
-  readonly has_event_key: boolean;
-  readonly has_signing_key: boolean;
-  readonly has_signing_key_fallback: boolean;
-  readonly mode: "cloud" | "dev";
-  readonly schema_version: "2024-05-24";
-  readonly extra?: {
-    readonly [x: string]: unknown;
-  } | undefined;
-} & {
-  readonly authentication_succeeded: false | null;
-  readonly functions?: readonly unknown[] | undefined;
-}), never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", never, never, never, never, {
-  readonly message?: string | undefined;
-}, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", never, {
-  readonly fnId: string;
-  readonly stepId?: string | undefined;
-}, never, never, unknown, never, never, never>, FunctionNotFoundError | InvalidRequestError | SignatureError, never, false>;
+declare class InngestApiGroup extends InngestApiGroup_base {}
 /**
  * @since 0.1.0
  * @category layers
  */
-declare const layerGroup: <ApiId extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, ApiError, ApiR>(api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>, group: InngestGroup.Any) => Layer.Layer<HttpApiGroup.ApiGroup<ApiId, "inngest">, never, InngestClient | HttpClient.HttpClient>;
+declare const layerGroup: <ApiId extends string, Groups extends HttpApiGroup.Any>(api: HttpApi.HttpApi<ApiId, Groups>, group: InngestGroup.Any) => Layer.Layer<HttpApiGroup.ApiGroup<ApiId, "inngest">, never, InngestClient | HttpClient.HttpClient>;
 //#endregion
 export { HttpApi_d_exports, InngestApiGroup, layerGroup };

package/dist/HttpApi.js

@@ -1,18 +1,17 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { IntrospectionResponse, RegisterResponse } from "./internal/protocol.js";
 import { SignatureError, SignatureLive } from "./internal/signature.js";
 import { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody } from "./internal/handler.js";
-import "@effect/platform/HttpClient";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
 import * as Effect from "effect/Effect";
-import "effect/Layer";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import "@effect/platform/HttpApi";
-import * as HttpApiBuilder from "@effect/platform/HttpApiBuilder";
-import * as HttpApiEndpoint from "@effect/platform/HttpApiEndpoint";
-import * as HttpApiGroup from "@effect/platform/HttpApiGroup";
-
+import "effect/unstable/http/HttpClient";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as Layer from "effect/Layer";
+import "effect/unstable/httpapi/HttpApi";
+import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
 //#region src/HttpApi.ts
 var HttpApi_exports = /* @__PURE__ */ __exportAll({
 	InngestApiGroup: () => InngestApiGroup,
@@ -22,15 +21,30 @@ const ExecuteParams = Schema.Struct({
 	fnId: Schema.String,
 	stepId: Schema.optional(Schema.String)
 });
-var FunctionNotFoundError = class extends Schema.TaggedError()("FunctionNotFoundError", { message: Schema.String }) {};
-const IntrospectEndpoint = HttpApiEndpoint.get("introspect", "/").addSuccess(IntrospectionResponse);
-const RegisterEndpoint = HttpApiEndpoint.put("register", "/").addSuccess(RegisterResponse);
-const ExecuteEndpoint = HttpApiEndpoint.post("execute", "/").setUrlParams(ExecuteParams).addSuccess(Schema.Unknown);
+var FunctionNotFoundError = class extends Schema.TaggedErrorClass()("FunctionNotFoundError", { message: Schema.String }) {};
+const CommonErrors = [
+	FunctionNotFoundError,
+	InvalidRequestError,
+	SignatureError
+];
+const IntrospectEndpoint = HttpApiEndpoint.get("introspect", "/", {
+	success: IntrospectionResponse,
+	error: CommonErrors
+});
+const RegisterEndpoint = HttpApiEndpoint.put("register", "/", {
+	success: RegisterResponse,
+	error: CommonErrors
+});
+const ExecuteEndpoint = HttpApiEndpoint.post("execute", "/", {
+	query: ExecuteParams,
+	success: Schema.Unknown,
+	error: CommonErrors
+});
 /**
 * @since 0.1.0
 * @category api
 */
-const InngestApiGroup = HttpApiGroup.make("inngest").add(IntrospectEndpoint).add(RegisterEndpoint).add(ExecuteEndpoint).addError(FunctionNotFoundError, { status: 404 }).addError(InvalidRequestError, { status: 400 }).addError(SignatureError, { status: 401 });
+var InngestApiGroup = class extends HttpApiGroup.make("inngest").add(IntrospectEndpoint).add(RegisterEndpoint).add(ExecuteEndpoint) {};
 /**
 * @since 0.1.0
 * @category layers
@@ -40,8 +54,9 @@ const layerGroup = (api, group) => {
 		onNone: () => req.url,
 		onSome: (url) => url.toString()
 	});
-	return HttpApiBuilder.group(api, "inngest", (handlers) => handlers.handle("introspect", ({ request }) => handleIntrospection(group, toUrl(request)).pipe(Effect.map((r) => r.body))).handle("register", ({ request }) => handleRegistration(group, toUrl(request)).pipe(Effect.map((r) => r.body))).handleRaw("execute", ({ urlParams, request }) => verifyAndParseRequestBody(request).pipe(Effect.provide(SignatureLive), Effect.flatMap((payload) => handleExecution(group, urlParams.fnId, urlParams.stepId, payload)), Effect.map((r) => r.body))));
+	return HttpApiBuilder.group(api, "inngest", Effect.fn(function* (handlers) {
+		return handlers.handle("introspect", ({ request }) => handleIntrospection(group, toUrl(request)).pipe(Effect.map((r) => r.body))).handle("register", ({ request }) => handleRegistration(group, toUrl(request)).pipe(Effect.map((r) => r.body))).handleRaw("execute", ({ query, request }) => verifyAndParseRequestBody(request).pipe(Effect.flatMap((payload) => handleExecution(group, query.fnId, query.stepId, payload)), Effect.map((r) => r.body)));
+	})).pipe(Layer.provide(SignatureLive));
 };
-
 //#endregion
-export { HttpApi_exports, InngestApiGroup, layerGroup };
+export { HttpApi_exports, InngestApiGroup, layerGroup };

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/index.js

@@ -4,5 +4,4 @@ import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Group_exports } from "./Group.js";
 import { HttpApi_exports } from "./HttpApi.js";
 import { Events_exports } from "./Events.js";
-
-export { Client_exports as InngestClient, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+export { Client_exports as InngestClient, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/internal/checkpoint.d.ts

@@ -0,0 +1,32 @@
+import * as Duration from "effect/Duration";
+import * as Schema from "effect/Schema";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/internal/checkpoint.d.ts
+declare const CheckpointApiError_base: Schema.Class<CheckpointApiError, Schema.TaggedStruct<"CheckpointApiError", {
+  readonly message: Schema.String;
+  readonly status: Schema.optionalKey<Schema.Number>;
+}>, _$effect_Cause0.YieldableError>;
+/**
+ * Tagged error returned by `InngestClient.checkpointAsync` when the API call
+ * fails (network error or non-2xx after retries). The driver and step tools
+ * treat this as a graceful-fallback signal — buffered steps are restored to
+ * the buffer so they get included in the final 206 response.
+ */
+declare class CheckpointApiError extends CheckpointApiError_base {}
+/**
+ * User-facing checkpointing option, accepted on `ClientConfig.checkpointing`
+ * and `FunctionOptions.checkpointing`.
+ *
+ * - `false` disables checkpointing entirely (no API calls; classic 206-per-step).
+ * - `true` enables checkpointing with the safe defaults
+ *   (`bufferedSteps: 1`, `maxInterval: 0`, `maxRuntime: 10 seconds`).
+ * - An object lets you tune `bufferedSteps`, `maxInterval`, `maxRuntime`.
+ */
+type CheckpointingOption = boolean | {
+  readonly bufferedSteps?: number;
+  readonly maxInterval?: Duration.Input;
+  readonly maxRuntime?: Duration.Input;
+};
+//#endregion
+export { CheckpointApiError, CheckpointingOption };

package/dist/internal/checkpoint.js

@@ -0,0 +1,112 @@
+import { timeStr } from "./helpers.js";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+//#region src/internal/checkpoint.ts
+/**
+* Checkpoint configuration + per-execution state for spec §10 async
+* checkpointing.
+*
+* Sync checkpointing (§10.3.2 / §10.4.2) is intentionally out of scope —
+* it requires a durable endpoint primitive the SDK does not yet expose.
+*
+* @internal
+*/
+/**
+* Tagged error returned by `InngestClient.checkpointAsync` when the API call
+* fails (network error or non-2xx after retries). The driver and step tools
+* treat this as a graceful-fallback signal — buffered steps are restored to
+* the buffer so they get included in the final 206 response.
+*/
+var CheckpointApiError = class extends Schema.TaggedErrorClass()("CheckpointApiError", {
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Number)
+}) {};
+const DEFAULTS = {
+	bufferedSteps: 1,
+	maxInterval: Duration.millis(0),
+	maxRuntime: Duration.seconds(10)
+};
+const normalize = (option) => ({
+	bufferedSteps: option.bufferedSteps ?? DEFAULTS.bufferedSteps,
+	maxInterval: option.maxInterval !== void 0 ? Duration.fromInputUnsafe(option.maxInterval) : DEFAULTS.maxInterval,
+	maxRuntime: option.maxRuntime !== void 0 ? Duration.fromInputUnsafe(option.maxRuntime) : DEFAULTS.maxRuntime
+});
+/**
+* Resolve final config from function-level + client-level settings.
+*
+* Precedence: function-level explicit > client-level explicit > built-in
+* defaults (default-ON, matching the TS reference SDK).
+*
+* Returns `undefined` if either level explicitly disables checkpointing.
+*/
+const resolveConfig = (fnLevel, clientLevel) => {
+	if (fnLevel === false) return void 0;
+	if (fnLevel === true) return DEFAULTS;
+	if (fnLevel !== void 0) return normalize(fnLevel);
+	if (clientLevel === false) return void 0;
+	if (clientLevel === true) return DEFAULTS;
+	if (clientLevel !== void 0) return normalize(clientLevel);
+	return DEFAULTS;
+};
+const toRegistration = (cfg) => ({
+	batch_steps: cfg.bufferedSteps,
+	batch_interval: timeStr(cfg.maxInterval),
+	max_runtime: timeStr(cfg.maxRuntime)
+});
+/**
+* Construct a `CheckpointState`. Caller supplies a pre-bound `checkpointAsync`
+* callback (typically `(steps) => client.checkpointAsync({runId, fnId, qiId, steps})`),
+* so this module has no dependency on `InngestClient`.
+*/
+const make = (args) => Effect.sync(() => {
+	const buffer = Ref.makeUnsafe([]);
+	const intervalStartedAt = Ref.makeUnsafe(Option.none());
+	const runtimeExceeded = Ref.makeUnsafe(false);
+	const maxIntervalMs = Duration.toMillis(args.config.maxInterval);
+	const flushInner = Effect.gen(function* () {
+		const steps = yield* Ref.modify(buffer, (current) => [current, []]);
+		if (steps.length === 0) return;
+		const result = yield* Effect.result(args.checkpointAsync(steps));
+		if (Result.isFailure(result)) {
+			yield* Ref.update(buffer, (current) => [...steps, ...current]);
+			return;
+		}
+		yield* Ref.set(intervalStartedAt, Option.none());
+	});
+	const bufferStep = (op) => Effect.gen(function* () {
+		const len = yield* Ref.modify(buffer, (current) => {
+			const next = [...current, op];
+			return [next.length, next];
+		});
+		const now = yield* Clock.currentTimeMillis;
+		const start = yield* Ref.get(intervalStartedAt);
+		if (len >= args.config.bufferedSteps) {
+			yield* flushInner;
+			return;
+		}
+		if (Option.isSome(start) && maxIntervalMs > 0 && now - start.value >= maxIntervalMs) {
+			yield* flushInner;
+			return;
+		}
+		if (Option.isNone(start) && maxIntervalMs > 0) yield* Ref.set(intervalStartedAt, Option.some(now));
+	});
+	const drain = Ref.modify(buffer, (current) => [current, []]);
+	return {
+		config: args.config,
+		runId: args.runId,
+		fnId: args.fnId,
+		qiId: args.qiId,
+		bufferStep,
+		flush: flushInner,
+		drain,
+		markRuntimeExceeded: Ref.set(runtimeExceeded, true),
+		isRuntimeExceeded: Ref.get(runtimeExceeded)
+	};
+});
+//#endregion
+export { CheckpointApiError, make, resolveConfig, toRegistration };

package/dist/internal/constants.js

@@ -10,6 +10,5 @@ const OtelAttributes = {
 	ExceptionMessage: "exception.message",
 	ExceptionStacktrace: "exception.stacktrace"
 };
-
 //#endregion
-export { OtelAttributes };
+export { OtelAttributes };

package/dist/internal/driver.d.ts

@@ -1,5 +1 @@
-import "../Client.js";
-import "../Function.js";
-import "./protocol.js";
-import "./step.js";
-import { Effect, Schema } from "effect";
+export { };