effect-inngest 0.1.2 → 0.2.0-beta.0

package/dist/internal/driver.js

@@ -1,12 +1,24 @@
-import { GeneratorOpcode, Headers as Headers$1, Opcode, UserError } from "./protocol.js";
+import { make } from "./checkpoint.js";
+import { GeneratorOpcode, Headers as Headers$1, Opcode, UserError, discoveryRequest, runComplete } from "./protocol.js";
+import { InngestClient } from "../Client.js";
 import { isNonRetriableError, isRetryAfterError, isStepError } from "./errors.js";
 import { StepInterrupt } from "./interrupts.js";
 import { OtelAttributes } from "./constants.js";
-import { Step, buildHandlerContext, createStepTools } from "./step.js";
-import { Array as Array$1, Chunk, Duration, Effect, HashMap, Option, Predicate, Ref, Schema, pipe } from "effect";
-import * as Headers from "@effect/platform/Headers";
-import * as HttpTraceContext from "@effect/platform/HttpTraceContext";
-
+import { buildHandlerContext, createStepTools } from "./step.js";
+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 Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Headers from "effect/unstable/http/Headers";
+import * as Cause from "effect/Cause";
+import * as HttpTraceContext from "effect/unstable/http/HttpTraceContext";
+import * as Chunk from "effect/Chunk";
+import * as HashMap from "effect/HashMap";
+import { pipe } from "effect/Function";
 //#region src/internal/driver.ts
 /**
 * Driver execution logic.
@@ -14,20 +26,21 @@ import * as HttpTraceContext from "@effect/platform/HttpTraceContext";
 */
 const SDK_VERSION = "2.0.0";
 var ExecutionResult = class extends Schema.Class("ExecutionResult")({
-	status: Schema.Literal(200, 206, 500),
+	status: Schema.Literals([
+		200,
+		206,
+		400,
+		500
+	]),
 	body: Schema.Unknown,
-	headers: Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	})
+	headers: Schema.Record(Schema.String, Schema.String)
 }) {};
 const isStepInterrupt = Schema.is(StepInterrupt);
-const isSomeWithValue = (v) => Predicate.isRecord(v) && Predicate.hasProperty(v, "_tag") && v._tag === "Some" && Predicate.hasProperty(v, "value");
-const extractStepInterrupt = (value) => pipe(Option.liftPredicate(isStepInterrupt)(value), Option.orElse(() => pipe(Option.liftPredicate(isSomeWithValue)(value), Option.flatMap((v) => Option.liftPredicate(isStepInterrupt)(v.value)))));
-const collectStepInterruptsFromError = (error) => pipe(extractStepInterrupt(error), Option.match({
-	onSome: Chunk.of,
-	onNone: () => Array.isArray(error) ? Chunk.fromIterable(Array$1.filterMap(error, extractStepInterrupt)) : Chunk.empty()
-}));
+const collectStepInterruptsFromCause = (cause) => {
+	const interrupts = [];
+	for (const reason of cause.reasons) if (Cause.isFailReason(reason) && isStepInterrupt(reason.error)) interrupts.push(reason.error);
+	return Chunk.fromIterable(interrupts);
+};
 const toUserError = (error) => UserError.make({
 	name: Predicate.hasProperty(error, "name") ? String(error.name) : "Error",
 	message: Predicate.hasProperty(error, "message") ? String(error.message) : String(error),
@@ -36,65 +49,164 @@ const toUserError = (error) => UserError.make({
 const baseHeaders = () => ({
 	"Content-Type": "application/json",
 	[Headers$1.SDK]: `effect-inngest:v${SDK_VERSION}`,
-	[Headers$1.RequestVersion]: "1"
+	[Headers$1.RequestVersion]: "2"
 });
-const execute = (fn, handler, request, appName, traceHeaders = {}) => Effect.gen(function* () {
-	const step = createStepTools(request, appName, yield* Ref.make(HashMap.empty()));
-	const context = buildHandlerContext(fn, step, request);
+const encodeOpcodes = (opcodes) => Schema.encodeSync(Schema.Array(GeneratorOpcode))(opcodes);
+const execute = (fn, handler, request, appName, traceHeaders = {}, checkpointConfig = Option.none()) => Effect.gen(function* () {
+	const stepIdCounts = yield* Ref.make(HashMap.empty());
 	const headers = baseHeaders();
-	return yield* handler(context).pipe(Effect.provideService(Step, step), Effect.map((value) => ExecutionResult.make({
-		status: 200,
-		body: value,
-		headers
-	})), Effect.catchAll((error) => {
-		const interrupts = collectStepInterruptsFromError(error);
+	const checkpointState = yield* Option.match(checkpointConfig, {
+		onNone: () => Effect.succeed(Option.none()),
+		onSome: (config) => Effect.gen(function* () {
+			const client = yield* InngestClient;
+			const state = yield* make({
+				config,
+				runId: request.ctx.run_id,
+				fnId: request.ctx.fn_id,
+				qiId: request.ctx.qi_id,
+				checkpointAsync: (steps) => client.checkpointAsync({
+					runId: request.ctx.run_id,
+					fnId: request.ctx.fn_id,
+					qiId: request.ctx.qi_id,
+					steps
+				})
+			});
+			return Option.some(state);
+		})
+	});
+	const context = buildHandlerContext(fn, createStepTools(request, appName, stepIdCounts, checkpointState), request);
+	/**
+	* Drain any unflushed buffered opcodes (no-op outside checkpoint mode).
+	* Used at every terminal branch so step results are never lost.
+	*/
+	const drainBuffer = Option.match(checkpointState, {
+		onNone: () => Effect.succeed([]),
+		onSome: (state) => state.drain
+	});
+	const handlerWithRace = Option.match(checkpointState, {
+		onNone: () => Effect.map(handler(context), Option.some),
+		onSome: (state) => Effect.raceFirst(Effect.map(handler(context), Option.some), Effect.sleep(state.config.maxRuntime).pipe(Effect.tap(() => state.markRuntimeExceeded), Effect.as(Option.none())))
+	});
+	return yield* Effect.scoped(handlerWithRace).pipe(Effect.flatMap((raced) => Effect.gen(function* () {
+		const drained = yield* drainBuffer;
+		if (Option.isSome(checkpointState)) {
+			const terminal = (yield* checkpointState.value.isRuntimeExceeded) || Option.isNone(raced) ? discoveryRequest() : runComplete(raced.value);
+			const opcodes = [...drained, terminal];
+			return ExecutionResult.make({
+				status: 206,
+				body: encodeOpcodes(opcodes),
+				headers
+			});
+		}
+		return ExecutionResult.make({
+			status: 200,
+			body: Option.getOrThrow(raced),
+			headers
+		});
+	})), Effect.catchCause((cause) => Effect.gen(function* () {
+		const drained = yield* drainBuffer;
+		const interrupts = collectStepInterruptsFromCause(cause);
 		if (!Chunk.isEmpty(interrupts)) {
 			const interruptArray = Chunk.toReadonlyArray(interrupts);
-			const opcodes = interruptArray.map((interrupt) => interrupt.opcode);
-			const hasNonRetriableError = opcodes.some((op) => op.op === Opcode.StepError && Predicate.isRecord(op.error) && Predicate.hasProperty(op.error, "noRetry") && op.error.noRetry === true);
+			const opcodes = [...drained, ...interruptArray.map((interrupt) => interrupt.opcode)];
+			const hasNonRetriableError = opcodes.some((op) => op.op === Opcode.StepError && Predicate.isObject(op.error) && Predicate.hasProperty(op.error, "noRetry") && op.error.noRetry === true);
 			const retryAfterMs = interruptArray.find((i) => i.retryAfterMs !== void 0)?.retryAfterMs;
 			const responseHeaders = hasNonRetriableError ? {
 				...headers,
 				[Headers$1.NoRetry]: "true"
 			} : headers;
-			if (retryAfterMs !== void 0) responseHeaders[Headers$1.RetryAfter] = String(Math.ceil(retryAfterMs / 1e3));
-			const encodedOpcodes = Schema.encodeSync(Schema.Array(GeneratorOpcode))(opcodes);
-			return Effect.succeed(ExecutionResult.make({
+			if (retryAfterMs !== void 0) {
+				responseHeaders[Headers$1.RetryAfter] = String(Math.ceil(retryAfterMs / 1e3));
+				responseHeaders[Headers$1.NoRetry] = "false";
+			}
+			return ExecutionResult.make({
 				status: 206,
-				body: encodedOpcodes,
+				body: encodeOpcodes(opcodes),
 				headers: responseHeaders
-			}));
+			});
 		}
+		const errorOpt = Option.orElse(Cause.findErrorOption(cause), () => {
+			const dieReason = cause.reasons.find(Cause.isDieReason);
+			return dieReason ? Option.some(dieReason.defect) : Option.none();
+		});
+		if (Option.isNone(errorOpt)) {
+			if (drained.length > 0) return ExecutionResult.make({
+				status: 206,
+				body: encodeOpcodes(drained),
+				headers
+			});
+			return ExecutionResult.make({
+				status: 500,
+				body: {
+					name: "Error",
+					message: "Unknown error"
+				},
+				headers: {
+					...headers,
+					[Headers$1.NoRetry]: "false"
+				}
+			});
+		}
+		const error = errorOpt.value;
 		if (isRetryAfterError(error)) {
 			const retryAfterMs = Duration.toMillis(error.retryAfter);
 			const retryAfterSeconds = Math.ceil(retryAfterMs / 1e3);
-			return Effect.succeed(ExecutionResult.make({
+			if (drained.length > 0) return ExecutionResult.make({
+				status: 206,
+				body: encodeOpcodes(drained),
+				headers: {
+					...headers,
+					[Headers$1.NoRetry]: "false",
+					[Headers$1.RetryAfter]: String(retryAfterSeconds)
+				}
+			});
+			return ExecutionResult.make({
 				status: 500,
-				body: { error: toUserError(error) },
+				body: toUserError(error),
 				headers: {
 					...headers,
 					[Headers$1.NoRetry]: "false",
 					[Headers$1.RetryAfter]: String(retryAfterSeconds)
 				}
-			}));
+			});
 		}
-		const noRetry = isNonRetriableError(error) || isStepError(error) && error.noRetry === true ? "true" : "false";
-		return Effect.succeed(ExecutionResult.make({
-			status: 500,
-			body: { error: toUserError(error) },
+		const noRetryValue = isNonRetriableError(error) || isStepError(error) && error.noRetry === true;
+		const noRetry = noRetryValue ? "true" : "false";
+		if (drained.length > 0) return ExecutionResult.make({
+			status: 206,
+			body: encodeOpcodes(drained),
 			headers: {
 				...headers,
 				[Headers$1.NoRetry]: noRetry
 			}
-		}));
-	}), Effect.catchAllDefect((defect) => Effect.succeed(ExecutionResult.make({
-		status: 500,
-		body: { error: toUserError(defect) },
-		headers: {
-			...headers,
-			[Headers$1.NoRetry]: "false"
-		}
-	}))));
+		});
+		return ExecutionResult.make({
+			status: noRetryValue ? 400 : 500,
+			body: toUserError(error),
+			headers: {
+				...headers,
+				[Headers$1.NoRetry]: noRetry
+			}
+		});
+	})), Effect.catchDefect((defect) => Effect.gen(function* () {
+		const drained = yield* drainBuffer;
+		if (drained.length > 0) return ExecutionResult.make({
+			status: 206,
+			body: encodeOpcodes(drained),
+			headers: {
+				...headers,
+				[Headers$1.NoRetry]: "false"
+			}
+		});
+		return ExecutionResult.make({
+			status: 500,
+			body: toUserError(defect),
+			headers: {
+				...headers,
+				[Headers$1.NoRetry]: "false"
+			}
+		});
+	})));
 }).pipe((base) => {
 	const headers = {};
 	if (traceHeaders.traceparent) headers["traceparent"] = traceHeaders.traceparent;
@@ -112,6 +224,6 @@ const execute = (fn, handler, request, appName, traceHeaders = {}) => Effect.gen
 		[OtelAttributes.Attempt]: request.ctx.attempt
 	}
 }));
-
+Context.Service()("effect-inngest/Driver");
 //#endregion
-export { execute };
+export { execute };

package/dist/internal/errors.d.ts

@@ -1,34 +1,29 @@
 import * as Schema from "effect/Schema";
+import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/internal/errors.d.ts
-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>;
 /**
  * @internal
  */
 declare class SendEventError extends SendEventError_base {}
-declare const StepError_base: Schema.TaggedErrorClass<StepError, "StepError", {
-  readonly _tag: Schema.tag<"StepError">;
-} & {
-  message: typeof Schema.String;
-  stepId: typeof Schema.String;
-  cause: Schema.optional<typeof Schema.Unknown>;
-  noRetry: Schema.optional<typeof Schema.Boolean>;
-}>;
+declare const StepError_base: Schema.Class<StepError, Schema.TaggedStruct<"StepError", {
+  readonly message: Schema.String;
+  readonly stepId: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+  readonly noRetry: Schema.optional<Schema.Boolean>;
+}>, _$effect_Cause0.YieldableError>;
 /**
  * @internal
  */
 declare class StepError extends StepError_base {}
-declare const NonRetriableError_base: Schema.TaggedErrorClass<NonRetriableError, "NonRetriableError", {
-  readonly _tag: Schema.tag<"NonRetriableError">;
-} & {
-  message: typeof Schema.String;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}>;
+declare const NonRetriableError_base: Schema.Class<NonRetriableError, Schema.TaggedStruct<"NonRetriableError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
 /**
  * Thrown to indicate that the error should not be retried.
  * Use this when you know retrying won't help (e.g., validation errors, auth failures).
@@ -37,13 +32,11 @@ declare const NonRetriableError_base: Schema.TaggedErrorClass<NonRetriableError,
  * @category errors
  */
 declare class NonRetriableError extends NonRetriableError_base {}
-declare const RetryAfterError_base: Schema.TaggedErrorClass<RetryAfterError, "RetryAfterError", {
-  readonly _tag: Schema.tag<"RetryAfterError">;
-} & {
-  message: typeof Schema.String;
-  retryAfter: typeof Schema.DurationFromMillis;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}>;
+declare const RetryAfterError_base: Schema.Class<RetryAfterError, Schema.TaggedStruct<"RetryAfterError", {
+  readonly message: Schema.String;
+  readonly retryAfter: Schema.DurationFromMillis;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
 /**
  * Thrown to indicate that the operation should be retried after a specific delay.
  * Use this for rate limiting or when you know when a resource will become available.

package/dist/internal/errors.js

@@ -1,21 +1,31 @@
 import * as Schema from "effect/Schema";
-
-//#region src/internal/errors.ts
-/**
-* Internal error types for the Effect Inngest SDK.
-* @internal
-*/
+import * as Predicate from "effect/Predicate";
+Schema.TaggedErrorClass()("SignatureError", { message: Schema.String });
+Schema.TaggedErrorClass()("RegistrationError", {
+	message: Schema.String,
+	functions: Schema.Array(Schema.String)
+});
+Schema.TaggedErrorClass()("FunctionNotFoundError", {
+	message: Schema.String,
+	functionId: Schema.String
+});
 /**
 * @internal
 */
-var SendEventError = class extends Schema.TaggedError()("SendEventError", {
+var SendEventError = class extends Schema.TaggedErrorClass()("SendEventError", {
 	message: Schema.String,
 	events: Schema.Array(Schema.String)
 }) {};
+Schema.TaggedErrorClass()("UseApiFetchError", {
+	message: Schema.String,
+	endpoint: Schema.Literals(["batch", "actions"]),
+	runId: Schema.String,
+	statusCode: Schema.optional(Schema.Number)
+});
 /**
 * @internal
 */
-var StepError = class extends Schema.TaggedError()("StepError", {
+var StepError = class extends Schema.TaggedErrorClass()("StepError", {
 	message: Schema.String,
 	stepId: Schema.String,
 	cause: Schema.optional(Schema.Unknown),
@@ -24,7 +34,12 @@ var StepError = class extends Schema.TaggedError()("StepError", {
 /**
 * @internal
 */
-const isStepError = Schema.is(StepError);
+const isStepError = Predicate.isTagged("StepError");
+Schema.TaggedErrorClass()("TimeoutError", {
+	message: Schema.String,
+	stepId: Schema.optional(Schema.String),
+	timeout: Schema.DurationFromMillis
+});
 /**
 * Thrown to indicate that the error should not be retried.
 * Use this when you know retrying won't help (e.g., validation errors, auth failures).
@@ -32,14 +47,14 @@ const isStepError = Schema.is(StepError);
 * @since 0.1.0
 * @category errors
 */
-var NonRetriableError = class extends Schema.TaggedError()("NonRetriableError", {
+var NonRetriableError = class extends Schema.TaggedErrorClass()("NonRetriableError", {
 	message: Schema.String,
 	cause: Schema.optional(Schema.Unknown)
 }) {};
 /**
 * @internal
 */
-const isNonRetriableError = Schema.is(NonRetriableError);
+const isNonRetriableError = Predicate.isTagged("NonRetriableError");
 /**
 * Thrown to indicate that the operation should be retried after a specific delay.
 * Use this for rate limiting or when you know when a resource will become available.
@@ -47,7 +62,7 @@ const isNonRetriableError = Schema.is(NonRetriableError);
 * @since 0.1.0
 * @category errors
 */
-var RetryAfterError = class extends Schema.TaggedError()("RetryAfterError", {
+var RetryAfterError = class extends Schema.TaggedErrorClass()("RetryAfterError", {
 	message: Schema.String,
 	retryAfter: Schema.DurationFromMillis,
 	cause: Schema.optional(Schema.Unknown)
@@ -55,7 +70,6 @@ var RetryAfterError = class extends Schema.TaggedError()("RetryAfterError", {
 /**
 * @internal
 */
-const isRetryAfterError = Schema.is(RetryAfterError);
-
+const isRetryAfterError = Predicate.isTagged("RetryAfterError");
 //#endregion
-export { NonRetriableError, RetryAfterError, SendEventError, StepError, isNonRetriableError, isRetryAfterError, isStepError };
+export { NonRetriableError, RetryAfterError, SendEventError, StepError, isNonRetriableError, isRetryAfterError, isStepError };

package/dist/internal/handler.d.ts

@@ -1,20 +1,11 @@
-import "../Client.js";
-import "./protocol.js";
-import "../Group.js";
 import { SignatureError } from "./signature.js";
-import "./driver.js";
-import "@effect/platform/HttpClient";
-import "@effect/platform/HttpServerRequest";
-import "effect/Context";
-import "effect/Effect";
 import * as Schema from "effect/Schema";
+import * as Cause from "effect/Cause";
 
 //#region src/internal/handler.d.ts
-declare const InvalidRequestError_base: Schema.TaggedErrorClass<InvalidRequestError, "InvalidRequestError", {
-  readonly _tag: Schema.tag<"InvalidRequestError">;
-} & {
-  message: typeof Schema.String;
-}>;
+declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequestError", {
+  readonly message: Schema.String;
+}>, Cause.YieldableError>;
 declare class InvalidRequestError extends InvalidRequestError_base {}
 //#endregion
 export { InvalidRequestError };

package/dist/internal/handler.js

@@ -1,27 +1,30 @@
-import { Headers, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import { resolveConfig } from "./checkpoint.js";
+import { Headers as Headers$1, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import { Signature } from "./signature.js";
 import { InngestClient } from "../Client.js";
-import { Signature, SignatureError } from "./signature.js";
 import { execute } from "./driver.js";
-import * as HttpClient from "@effect/platform/HttpClient";
-import "@effect/platform/HttpServerRequest";
-import "effect/Context";
 import * as Effect from "effect/Effect";
+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 HttpClient from "effect/unstable/http/HttpClient";
+import "effect/unstable/http/HttpServerRequest";
+import "effect/Context";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 import * as Predicate from "effect/Predicate";
-
+import * as Headers from "effect/unstable/http/Headers";
+import * as Cause from "effect/Cause";
 //#region src/internal/handler.ts
 /**
 * Internal handler implementation.
 * @internal
 */
-var InvalidRequestError = class extends Schema.TaggedError()("InvalidRequestError", { message: Schema.String }) {};
+var InvalidRequestError = class extends Schema.TaggedErrorClass()("InvalidRequestError", { message: Schema.String }) {};
 const SDK_VERSION = "2.0.0";
 const baseHeaders = () => ({
 	"Content-Type": "application/json",
-	[Headers.SDK]: `effect-inngest:v${SDK_VERSION}`,
-	[Headers.RequestVersion]: "1"
+	[Headers$1.SDK]: `effect-inngest:v${SDK_VERSION}`,
+	[Headers$1.RequestVersion]: "2"
 });
 const buildServeUrl = (requestUrl, serveHost, servePath) => {
 	const url = new URL(requestUrl);
@@ -29,22 +32,24 @@ const buildServeUrl = (requestUrl, serveHost, servePath) => {
 	if (serveHost) return new URL(url.pathname + url.search, serveHost);
 	return url;
 };
-const verifyAndParseRequestBody = (request) => Effect.gen(function* () {
+const verifyAndParseRequestBody = Effect.fn("effect-inngest/handler/verifyAndParseRequestBody")(function* (request) {
 	const client = yield* InngestClient;
 	const sig = yield* Signature;
 	const config = client.config;
 	const isDev = client.mode === "dev";
-	const bodyText = yield* request.text.pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Failed to read request body: ${String(error)}` })));
+	const bodyText = yield* request.text.pipe(Effect.mapError((error) => {
+		return new InvalidRequestError({ message: `Failed to read request body: ${Predicate.hasProperty(error, "message") && typeof error.message === "string" ? error.message : "unknown"}` });
+	}));
 	yield* sig.verify({
 		body: new TextEncoder().encode(bodyText),
-		signatureHeader: request.headers[Headers.Signature.toLowerCase()],
+		signatureHeader: Option.getOrUndefined(Headers.get(request.headers, Headers$1.Signature)),
 		signingKey: config.signingKey,
 		signingKeyFallback: config.signingKeyFallback,
 		isDev
 	});
-	return yield* Schema.decodeUnknown(Schema.parseJson(SDKRequestBody))(bodyText).pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Invalid request body: ${String(error)}` })));
+	return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(SDKRequestBody))(bodyText).pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Invalid request body: ${String(error)}` })));
 });
-const handleIntrospection = (group, _requestUrl) => Effect.gen(function* () {
+const handleIntrospection = Effect.fn("effect-inngest/handler/handleIntrospection")(function* (group, _requestUrl) {
 	const client = yield* InngestClient;
 	const config = client.config;
 	const body = {
@@ -62,16 +67,7 @@ const handleIntrospection = (group, _requestUrl) => Effect.gen(function* () {
 		body
 	};
 });
-const RegisterRequest = Schema.Struct({
-	url: Schema.String,
-	v: Schema.String,
-	deployType: Schema.Literal("ping"),
-	sdk: Schema.String,
-	appName: Schema.String,
-	framework: Schema.String,
-	functions: Schema.Array(Schema.Unknown)
-});
-const handleRegistration = (group, requestUrl) => Effect.gen(function* () {
+const handleRegistration = Effect.fn("effect-inngest/handler/handleRegistration")(function* (group, requestUrl) {
 	const client = yield* InngestClient;
 	const httpClient = yield* HttpClient.HttpClient;
 	const config = client.config;
@@ -81,10 +77,10 @@ const handleRegistration = (group, requestUrl) => Effect.gen(function* () {
 		url: url.href
 	}));
 	const registerUrl = new URL("fn/register", client.apiBaseUrl).toString();
-	const response = yield* HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
+	const request = HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
 		...baseHeaders(),
 		Authorization: `Bearer ${config.signingKey ?? ""}`
-	}), HttpClientRequest.schemaBodyJson(RegisterRequest)({
+	}), HttpClientRequest.bodyJsonUnsafe({
 		url: url.href,
 		v: "0.1",
 		deployType: "ping",
@@ -92,31 +88,58 @@ const handleRegistration = (group, requestUrl) => Effect.gen(function* () {
 		appName: config.id,
 		framework: "effect",
 		functions
-	})).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(RegisterResponse)), Effect.scoped, Effect.catchAll((error) => Effect.succeed({ message: `Registration failed: ${Predicate.hasProperty(error, "message") ? error.message : "Unknown error"}` })));
-	return {
-		status: 200,
-		headers: baseHeaders(),
-		body: response
-	};
+	}));
+	return yield* Effect.gen(function* () {
+		const response = yield* httpClient.execute(request).pipe(Effect.scoped);
+		const responseBody = yield* HttpClientResponse.schemaBodyJson(RegisterServerResponse)(response).pipe(Effect.catch(() => Effect.succeed({ error: "Unknown registration response" })));
+		if (response.status !== 200 || !Predicate.hasProperty(responseBody, "ok")) return {
+			status: 500,
+			headers: baseHeaders(),
+			body: {
+				message: Predicate.hasProperty(responseBody, "error") && responseBody.error ? responseBody.error : `Registration failed with status ${response.status}`,
+				modified: false
+			}
+		};
+		return {
+			status: 200,
+			headers: baseHeaders(),
+			body: {
+				message: "Successfully synced.",
+				modified: responseBody.modified ?? false
+			}
+		};
+	}).pipe(Effect.catchCause((cause) => {
+		const errorOpt = Cause.findErrorOption(cause);
+		const dieReason = cause.reasons.find(Cause.isDieReason);
+		const message = Option.isSome(errorOpt) ? Predicate.hasProperty(errorOpt.value, "message") && typeof errorOpt.value.message === "string" ? errorOpt.value.message : "Registration failed" : dieReason ? Predicate.hasProperty(dieReason.defect, "message") && typeof dieReason.defect.message === "string" ? dieReason.defect.message : "Registration failed" : "Registration failed";
+		return Effect.succeed({
+			status: 500,
+			headers: baseHeaders(),
+			body: {
+				message,
+				modified: false
+			}
+		});
+	}));
 });
-const handleExecution = (group, fnId, urlStepId, body, traceHeaders = {}) => Effect.gen(function* () {
+const handleExecution = Effect.fn("effect-inngest/handler/handleExecution")(function* (group, fnId, urlStepId, body, traceHeaders = {}) {
 	const client = yield* InngestClient;
 	const context = yield* Effect.context();
 	const appId = client.config.id;
 	const prefix = `${appId}-`;
 	const fnTag = fnId.startsWith(prefix) ? fnId.slice(prefix.length) : fnId;
 	const fn = group.functions.get(fnTag);
-	const entry = fn ? context.unsafeMap.get(fn.key) : void 0;
+	const entry = fn ? context.mapUnsafe.get(fn.key) : void 0;
 	if (!fn || !entry) return {
-		status: 404,
+		status: 500,
 		headers: {
 			...baseHeaders(),
-			[Headers.NoRetry]: "true"
+			[Headers$1.NoRetry]: "false"
 		},
-		body: { error: UserError.make({
+		body: UserError.make({
 			name: "FunctionNotFoundError",
 			message: `Unknown function: ${fnId}`
-		}) }
+		})
 	};
 	const effectiveBody = urlStepId && urlStepId !== body.ctx.step_id ? SDKRequestBody.make({
 		event: body.event,
@@ -125,21 +148,25 @@ const handleExecution = (group, fnId, urlStepId, body, traceHeaders = {}) => Eff
 		ctx: SDKRequestContext.make({
 			fn_id: body.ctx.fn_id,
 			run_id: body.ctx.run_id,
+			env: body.ctx.env,
 			step_id: urlStepId,
 			attempt: body.ctx.attempt,
+			max_attempts: body.ctx.max_attempts,
+			qi_id: body.ctx.qi_id,
 			disable_immediate_execution: body.ctx.disable_immediate_execution,
 			use_api: body.ctx.use_api,
 			stack: body.ctx.stack
 		}),
+		version: body.version,
 		use_api: body.use_api
 	}) : body;
-	const result = yield* Effect.provide(execute(fn, entry.handler, effectiveBody, appId, traceHeaders), entry.context);
+	const checkpointConfig = !urlStepId && effectiveBody.ctx.fn_id !== "" && !effectiveBody.ctx.disable_immediate_execution ? Option.fromNullishOr(resolveConfig(fn.options.checkpointing, client.config.checkpointing)) : Option.none();
+	const result = yield* Effect.provide(execute(fn, entry.handler, effectiveBody, appId, traceHeaders, checkpointConfig), entry.context);
 	return {
 		status: result.status,
 		headers: result.headers,
 		body: result.body
 	};
 });
-
 //#endregion
-export { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody };
+export { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody };