effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/internal/driver.js

@@ -1,117 +1,18 @@
-import { GeneratorOpcode, Headers as Headers$1, Opcode, UserError } from "./protocol.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 "./protocol.js";
+import { provide } from "./execution/ExecutionScope.js";
+import { run, withCheckpointDeadline } from "./execution/HandlerRun.js";
+import "./execution/ExecutionResult.js";
+import { fromExit } from "./execution/ExecutionResponse.js";
+import { Context, Effect, Layer, Option } from "effect";
 //#region src/internal/driver.ts
-/**
-* Driver execution logic.
-* @internal
-*/
-const SDK_VERSION = "2.0.0";
-var ExecutionResult = class extends Schema.Class("ExecutionResult")({
-	status: Schema.Literal(200, 206, 500),
-	body: Schema.Unknown,
-	headers: Schema.Record({
-		key: Schema.String,
-		value: 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 execute = (args) => run({
+	fn: args.fn,
+	handler: args.handler
+}).pipe(withCheckpointDeadline, Effect.scoped, Effect.exit, Effect.flatMap(fromExit), provide({
+	request: args.request,
+	checkpointConfig: args.checkpointConfig ?? Option.none()
 }));
-const toUserError = (error) => UserError.make({
-	name: Predicate.hasProperty(error, "name") ? String(error.name) : "Error",
-	message: Predicate.hasProperty(error, "message") ? String(error.message) : String(error),
-	stack: Predicate.hasProperty(error, "stack") ? String(error.stack) : void 0
-});
-const baseHeaders = () => ({
-	"Content-Type": "application/json",
-	[Headers$1.SDK]: `effect-inngest:v${SDK_VERSION}`,
-	[Headers$1.RequestVersion]: "1"
-});
-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 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);
-		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 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({
-				status: 206,
-				body: encodedOpcodes,
-				headers: responseHeaders
-			}));
-		}
-		if (isRetryAfterError(error)) {
-			const retryAfterMs = Duration.toMillis(error.retryAfter);
-			const retryAfterSeconds = Math.ceil(retryAfterMs / 1e3);
-			return Effect.succeed(ExecutionResult.make({
-				status: 500,
-				body: { error: 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) },
-			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"
-		}
-	}))));
-}).pipe((base) => {
-	const headers = {};
-	if (traceHeaders.traceparent) headers["traceparent"] = traceHeaders.traceparent;
-	if (traceHeaders.tracestate) headers["tracestate"] = traceHeaders.tracestate;
-	return pipe(HttpTraceContext.fromHeaders(Headers.fromInput(headers)), Option.match({
-		onNone: () => base,
-		onSome: (externalSpan) => Effect.withParentSpan(base, externalSpan)
-	}));
-}, Effect.withSpan(`inngest.function/${fn._tag}`, {
-	kind: "server",
-	attributes: {
-		[OtelAttributes.RunId]: request.ctx.run_id,
-		[OtelAttributes.FunctionId]: fn._tag,
-		[OtelAttributes.AppId]: appName,
-		[OtelAttributes.Attempt]: request.ctx.attempt
-	}
-}));
-
+var Driver = class extends Context.Service()("effect-inngest/Driver") {};
+Layer.succeed(Driver, { execute });
 //#endregion
-export { execute };
+export { execute };

package/dist/internal/errors.d.ts

@@ -1,56 +1,29 @@
-import * as Schema from "effect/Schema";
+import { Schema } from "effect";
+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>;
-}>;
-/**
- * @internal
- */
+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 {}
-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>;
-}>;
-/**
- * @internal
- */
+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>;
 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>;
-}>;
-/**
- * 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).
- *
- * @since 0.1.0
- * @category errors
- */
+declare const NonRetriableError_base: Schema.Class<NonRetriableError, Schema.TaggedStruct<"NonRetriableError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
 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>;
-}>;
-/**
- * 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.
- *
- * @since 0.1.0
- * @category errors
- */
+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>;
 declare class RetryAfterError extends RetryAfterError_base {}
 //#endregion
 export { NonRetriableError, RetryAfterError, SendEventError, StepError };

package/dist/internal/errors.js

@@ -1,61 +1,26 @@
-import * as Schema from "effect/Schema";
-
+import { Predicate, Schema } from "effect";
 //#region src/internal/errors.ts
-/**
-* Internal error types for the Effect Inngest SDK.
-* @internal
-*/
-/**
-* @internal
-*/
-var SendEventError = class extends Schema.TaggedError()("SendEventError", {
+var SendEventError = class extends Schema.TaggedErrorClass()("SendEventError", {
 	message: Schema.String,
 	events: Schema.Array(Schema.String)
 }) {};
-/**
-* @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),
 	noRetry: Schema.optional(Schema.Boolean)
 }) {};
-/**
-* @internal
-*/
-const isStepError = Schema.is(StepError);
-/**
-* 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).
-*
-* @since 0.1.0
-* @category errors
-*/
-var NonRetriableError = class extends Schema.TaggedError()("NonRetriableError", {
+const isStepError = Predicate.isTagged("StepError");
+var NonRetriableError = class extends Schema.TaggedErrorClass()("NonRetriableError", {
 	message: Schema.String,
 	cause: Schema.optional(Schema.Unknown)
 }) {};
-/**
-* @internal
-*/
-const isNonRetriableError = Schema.is(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.
-*
-* @since 0.1.0
-* @category errors
-*/
-var RetryAfterError = class extends Schema.TaggedError()("RetryAfterError", {
+const isNonRetriableError = Predicate.isTagged("NonRetriableError");
+var RetryAfterError = class extends Schema.TaggedErrorClass()("RetryAfterError", {
 	message: Schema.String,
 	retryAfter: Schema.DurationFromMillis,
 	cause: Schema.optional(Schema.Unknown)
 }) {};
-/**
-* @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/execution/CheckpointRun.js

@@ -0,0 +1,25 @@
+import { make as make$1 } from "../checkpoint/State.js";
+import "../protocol.js";
+import { InngestClient } from "../../Client.js";
+import { Effect, Option } from "effect";
+//#region src/internal/execution/CheckpointRun.ts
+const make = (args) => Option.match(args.config, {
+	onNone: () => Effect.succeed(Option.none()),
+	onSome: (config) => InngestClient.use((client) => make$1({
+		config,
+		runId: args.request.ctx.run_id,
+		fnId: args.request.ctx.fn_id,
+		qiId: args.request.ctx.qi_id,
+		checkpointAsync: (steps) => client.checkpointAsync({
+			runId: args.request.ctx.run_id,
+			fnId: args.request.ctx.fn_id,
+			qiId: args.request.ctx.qi_id,
+			requestId: args.request.ctx.request_id,
+			generationId: args.request.ctx.generation_id,
+			requestStartedAt: args.requestStartedAt,
+			steps
+		})
+	}).pipe(Effect.map(Option.some)))
+});
+//#endregion
+export { make };

package/dist/internal/execution/ExecutionFailure.js

@@ -0,0 +1,19 @@
+import { UserError } from "../protocol.js";
+import { Cause, Option, Schema } from "effect";
+//#region src/internal/execution/ExecutionFailure.ts
+var ExecutionFailure = class ExecutionFailure extends Schema.Class("effect-inngest/internal/execution/ExecutionFailure")({ error: Schema.Unknown }) {
+	static fromCause(cause) {
+		return ExecutionFailure.make({ error: ExecutionFailure.errorFromCause(cause) });
+	}
+	static errorFromCause(cause) {
+		return Option.orElse(Cause.findErrorOption(cause), () => {
+			const dieReason = cause.reasons.find(Cause.isDieReason);
+			return dieReason ? Option.some(dieReason.defect) : Option.none();
+		}).pipe(Option.getOrElse(() => UserError.make({
+			name: "Error",
+			message: "Unknown error"
+		})));
+	}
+};
+//#endregion
+export { ExecutionFailure };

package/dist/internal/execution/ExecutionHeaders.js

@@ -0,0 +1,58 @@
+import { Headers as Headers$1 } from "../protocol.js";
+import { isNonRetriableError, isRetryAfterError, isStepError } from "../errors.js";
+import { Duration, Option, Schema } from "effect";
+import * as Headers from "effect/unstable/http/Headers";
+//#region src/internal/execution/ExecutionHeaders.ts
+const SDK_VERSION = "2.0.0";
+var RetryDisposition = class RetryDisposition extends Schema.Class("effect-inngest/internal/execution/RetryDisposition")({
+	noRetry: Schema.Boolean,
+	isFailure: Schema.Boolean,
+	retryAfterMs: Schema.Option(Schema.Number)
+}) {
+	static none = RetryDisposition.make({
+		noRetry: false,
+		isFailure: false,
+		retryAfterMs: Option.none()
+	});
+	static failure(args) {
+		return RetryDisposition.make({
+			noRetry: args.noRetry,
+			isFailure: true,
+			retryAfterMs: args.retryAfterMs ?? Option.none()
+		});
+	}
+	static fromSuspension(commands) {
+		if (!commands.hasFailure && Option.isNone(commands.retryAfterMs)) return RetryDisposition.none;
+		return RetryDisposition.failure({
+			noRetry: commands.noRetry,
+			retryAfterMs: commands.retryAfterMs
+		});
+	}
+	static fromError(error) {
+		if (isRetryAfterError(error)) return RetryDisposition.failure({
+			noRetry: false,
+			retryAfterMs: Option.some(Duration.toMillis(error.retryAfter))
+		});
+		return RetryDisposition.failure({ noRetry: isNonRetriableError(error) || isStepError(error) && error.noRetry === true });
+	}
+	toHeaders() {
+		if (Option.isSome(this.retryAfterMs)) return Headers.fromInput({
+			[Headers$1.NoRetry]: "false",
+			[Headers$1.RetryAfter]: String(Math.ceil(this.retryAfterMs.value / 1e3))
+		});
+		if (this.noRetry) return Headers.fromInput({ [Headers$1.NoRetry]: "true" });
+		if (this.isFailure) return Headers.fromInput({ [Headers$1.NoRetry]: "false" });
+		return Headers.empty;
+	}
+};
+const base = (config) => Headers.fromInput({
+	"Content-Type": "application/json",
+	"User-Agent": `effect-inngest:v${SDK_VERSION}`,
+	[Headers$1.SDK]: `effect-inngest:v${SDK_VERSION}`,
+	[Headers$1.SDKHandled]: "true",
+	[Headers$1.RequestVersion]: "2",
+	...config.framework ? { [Headers$1.Framework]: config.framework } : {}
+});
+const merge = (headers, retry) => Headers.merge(headers, retry.toHeaders());
+//#endregion
+export { RetryDisposition, base, merge };

package/dist/internal/execution/ExecutionResponse.js

@@ -0,0 +1,68 @@
+import { GeneratorOpcode } from "../protocol.js";
+import { InngestConfig } from "../../Client.js";
+import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { StepCommandBus } from "../runtime/StepCommandBus.js";
+import { ExecutionFailure } from "./ExecutionFailure.js";
+import { RetryDisposition, base } from "./ExecutionHeaders.js";
+import { ExecutionResult } from "./ExecutionResult.js";
+import { Cause, Effect, Exit, Match, Option } from "effect";
+//#region src/internal/execution/ExecutionResponse.ts
+const fromSuccess = (args) => Effect.gen(function* () {
+	const bus = yield* StepCommandBus;
+	const checkpoint = yield* CurrentCheckpoint;
+	const completed = yield* bus.takeCompleted();
+	if (Option.isSome(checkpoint)) {
+		const terminal = Match.value(args.completion).pipe(Match.tag("CheckpointDeadlineElapsed", () => GeneratorOpcode.discoveryRequest()), Match.tag("HandlerSucceeded", (completion) => GeneratorOpcode.runComplete(completion.value)), Match.exhaustive);
+		return ExecutionResult.opcodes({
+			opcodes: [...completed, terminal],
+			headers: args.headers
+		});
+	}
+	return Match.value(args.completion).pipe(Match.tag("HandlerSucceeded", (completion) => ExecutionResult.success({
+		body: completion.value,
+		headers: args.headers
+	})), Match.tag("CheckpointDeadlineElapsed", () => ExecutionResult.checkpointDeadlineOutsideCheckpoint(args)), Match.exhaustive);
+});
+const fromFailure = (args) => Effect.gen(function* () {
+	const commands = yield* (yield* StepCommandBus).takeSuspension();
+	if (commands.suspendedCount > 0 && Cause.hasInterruptsOnly(args.cause)) return ExecutionResult.opcodesWithRetry({
+		opcodes: commands.opcodes,
+		headers: args.headers,
+		disposition: RetryDisposition.fromSuspension(commands)
+	});
+	if (Cause.hasInterruptsOnly(args.cause)) return yield* Effect.interrupt;
+	const failure = ExecutionFailure.fromCause(args.cause);
+	const disposition = RetryDisposition.fromError(failure.error);
+	if (commands.completed.length > 0) return ExecutionResult.opcodesWithRetry({
+		opcodes: commands.completed,
+		headers: args.headers,
+		disposition
+	});
+	return ExecutionResult.userError({
+		error: failure.error,
+		headers: args.headers,
+		disposition
+	});
+});
+const fromExit = (exit) => Effect.gen(function* () {
+	const config = yield* InngestConfig;
+	const bus = yield* StepCommandBus;
+	const headers = base(config);
+	const planned = yield* bus.takePlanned();
+	if (planned.length > 0) return ExecutionResult.opcodes({
+		opcodes: planned,
+		headers
+	});
+	return yield* Exit.match(exit, {
+		onSuccess: (completion) => fromSuccess({
+			completion,
+			headers
+		}),
+		onFailure: (cause) => fromFailure({
+			cause,
+			headers
+		})
+	});
+});
+//#endregion
+export { fromExit };

package/dist/internal/execution/ExecutionResult.js

@@ -0,0 +1,56 @@
+import { GeneratorOpcode, UserError } from "../protocol.js";
+import { RetryDisposition, merge } from "./ExecutionHeaders.js";
+import { Schema } from "effect";
+import * as Headers from "effect/unstable/http/Headers";
+//#region src/internal/execution/ExecutionResult.ts
+var ExecutionResult = class ExecutionResult extends Schema.Class("ExecutionResult")({
+	status: Schema.Literals([
+		200,
+		206,
+		400,
+		500
+	]),
+	body: Schema.Unknown,
+	headers: Headers.HeadersSchema
+}) {
+	static success(args) {
+		return ExecutionResult.make({
+			status: 200,
+			body: args.body,
+			headers: args.headers
+		});
+	}
+	static opcodes(args) {
+		return ExecutionResult.make({
+			status: 206,
+			body: encodeOpcodes(args.opcodes),
+			headers: args.headers
+		});
+	}
+	static opcodesWithRetry(args) {
+		return ExecutionResult.opcodes({
+			opcodes: args.opcodes,
+			headers: merge(args.headers, args.disposition)
+		});
+	}
+	static userError(args) {
+		return ExecutionResult.make({
+			status: args.disposition.noRetry ? 400 : 500,
+			body: UserError.fromUnknown(args.error),
+			headers: merge(args.headers, args.disposition)
+		});
+	}
+	static checkpointDeadlineOutsideCheckpoint(args) {
+		return ExecutionResult.make({
+			status: 500,
+			body: UserError.make({
+				name: "Error",
+				message: "Checkpoint deadline elapsed outside checkpoint mode"
+			}),
+			headers: merge(args.headers, RetryDisposition.failure({ noRetry: false }))
+		});
+	}
+};
+const encodeOpcodes = (opcodes) => Schema.encodeSync(Schema.Array(GeneratorOpcode))(opcodes);
+//#endregion
+export { ExecutionResult };

package/dist/internal/execution/ExecutionScope.js

@@ -0,0 +1,30 @@
+import "../protocol.js";
+import { InngestClient, InngestConfig } from "../../Client.js";
+import { make } from "./CheckpointRun.js";
+import { CurrentExecutionInput, ExecutionInput } from "../domain/ExecutionInput.js";
+import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { HandlerFiberScope } from "../runtime/HandlerFiberScope.js";
+import { StepCommandBus } from "../runtime/StepCommandBus.js";
+import { StepIdentity } from "../runtime/StepIdentity.js";
+import { StepTools } from "../runtime/StepTools.js";
+import { Clock, Context, Effect } from "effect";
+//#region src/internal/execution/ExecutionScope.ts
+const provide = (args) => (effect) => Effect.gen(function* () {
+	const client = yield* InngestClient;
+	const rootFiberId = yield* Effect.fiberId;
+	const requestStartedAt = yield* Clock.currentTimeMillis;
+	const input = ExecutionInput.fromSdkRequestBody(args.request);
+	const checkpoint = yield* make({
+		request: args.request,
+		config: args.checkpointConfig,
+		requestStartedAt
+	});
+	const bus = yield* StepCommandBus.make;
+	const identity = yield* StepIdentity.make;
+	const baseContext = Context.make(CurrentExecutionInput, input).pipe(Context.add(CurrentCheckpoint, checkpoint), Context.add(InngestConfig, client.config), Context.add(StepCommandBus, bus), Context.add(StepIdentity, identity), Context.add(HandlerFiberScope, { isForkedFromHandlerRoot: Effect.map(Effect.fiberId, (fiberId) => fiberId !== rootFiberId) }));
+	const stepTools = yield* StepTools.make.pipe(Effect.provide(baseContext));
+	const context = Context.add(baseContext, StepTools, stepTools);
+	return yield* effect.pipe(Effect.provide(context));
+});
+//#endregion
+export { provide };

package/dist/internal/execution/HandlerRun.js

@@ -0,0 +1,16 @@
+import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { make } from "../runtime/HandlerContext.js";
+import { Effect, Option, Schema } from "effect";
+//#region src/internal/execution/HandlerRun.ts
+var HandlerSucceeded = class extends Schema.TaggedClass()("HandlerSucceeded", { value: Schema.Unknown }) {};
+Schema.TaggedClass()("CheckpointDeadlineElapsed", {});
+const run = (args) => make({ fn: args.fn }).pipe(Effect.flatMap(args.handler), Effect.map((value) => HandlerSucceeded.make({ value })));
+const withCheckpointDeadline = (effect) => Effect.gen(function* () {
+	const checkpoint = yield* CurrentCheckpoint;
+	return yield* Option.match(checkpoint, {
+		onNone: () => effect,
+		onSome: (state) => Effect.sleep(state.config.maxRuntime).pipe(Effect.andThen(state.markRuntimeExceeded), Effect.forkScoped, Effect.andThen(effect))
+	});
+});
+//#endregion
+export { run, withCheckpointDeadline };

package/dist/internal/handler.d.ts

@@ -1,20 +1,9 @@
-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 { SignatureError } from "./serve/Signature.js";
+import { Cause, Context, Effect, Schema } from "effect";
 //#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 };