effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/internal/runtime/StepIdentity.d.ts

@@ -0,0 +1,27 @@
+import { StepInfo } from "../domain/StepInfo.js";
+import { StepInput } from "../domain/StepInput.js";
+import { Context, Effect, Layer, Schema } from "effect";
+
+//#region src/internal/runtime/StepIdentity.d.ts
+declare const StepReservation_base: Schema.Class<StepReservation, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+  readonly effectiveId: Schema.String;
+  readonly sequence: Schema.Number;
+  readonly rawStepArg: Schema.Unknown;
+}>, {}>;
+declare class StepReservation extends StepReservation_base {}
+declare const StepIdentity_base: Context.ServiceClass<StepIdentity, "effect-inngest/internal/runtime/StepIdentity", {
+  readonly reserve: (input: StepInput) => StepReservation;
+  readonly resolve: (reservation: StepReservation) => Effect.Effect<StepInfo>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly reserve: (input: StepInput) => StepReservation;
+    readonly resolve: (reservation: StepReservation) => Effect.Effect<StepInfo>;
+  }, never, never>;
+};
+declare class StepIdentity extends StepIdentity_base {
+  static readonly layer: Layer.Layer<StepIdentity, never, never>;
+}
+//#endregion
+export { StepIdentity };

package/dist/internal/runtime/StepIdentity.js

@@ -0,0 +1,46 @@
+import { StepInfo } from "../domain/StepInfo.js";
+import { Context, Effect, Encoding, Layer, MutableHashMap, MutableRef, Number, Option, Predicate, Schema } from "effect";
+//#region src/internal/runtime/StepIdentity.ts
+var StepReservation = class extends Schema.Class("effect-inngest/internal/runtime/StepReservation")({
+	id: Schema.String,
+	name: Schema.String,
+	effectiveId: Schema.String,
+	sequence: Schema.Number,
+	rawStepArg: Schema.Unknown
+}) {};
+var StepIdentity = class extends Context.Service()("effect-inngest/internal/runtime/StepIdentity", { make: Effect.gen(function* () {
+	const counts = MutableHashMap.empty();
+	const sequence = MutableRef.make(0);
+	const textEncoder = new TextEncoder();
+	return {
+		reserve: (input) => {
+			const id = Predicate.isString(input) ? input : input.id;
+			const name = Predicate.isString(input) ? input : input.name ?? input.id;
+			const currentSequence = MutableRef.getAndUpdate(sequence, Number.increment);
+			const repeatIndex = Option.getOrElse(MutableHashMap.get(counts, id), () => 0);
+			MutableHashMap.set(counts, id, Number.increment(repeatIndex));
+			const effectiveId = repeatIndex > 0 ? `${id}:${repeatIndex}` : id;
+			return StepReservation.make({
+				id,
+				name,
+				effectiveId,
+				sequence: currentSequence,
+				rawStepArg: input
+			});
+		},
+		resolve: Effect.fnUntraced(function* (reservation) {
+			const buffer = yield* Effect.promise(() => globalThis.crypto.subtle.digest("SHA-1", textEncoder.encode(reservation.effectiveId)));
+			const hash = Encoding.encodeHex(new Uint8Array(buffer));
+			return StepInfo.make({
+				id: reservation.id,
+				name: reservation.name,
+				hash,
+				rawStepArg: reservation.rawStepArg
+			});
+		})
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make);
+};
+//#endregion
+export { StepIdentity };

package/dist/internal/runtime/StepTools.d.ts

@@ -0,0 +1,83 @@
+import { InngestClient, InngestConfig } from "../../Client.js";
+import { EventType } from "../../Event.js";
+import { InngestFunction } from "../../Function.js";
+import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
+import { EventSchema } from "../codec/EventPayload.js";
+import { SendEventError, StepError } from "../errors.js";
+import { StepInput } from "../domain/StepInput.js";
+import { HandlerFiberScope } from "./HandlerFiberScope.js";
+import { StepCommandBus } from "./StepCommandBus.js";
+import { StepIdentity } from "./StepIdentity.js";
+import { Context, Duration, Effect, Layer, Option, Schema } from "effect";
+
+//#region src/internal/runtime/StepTools.d.ts
+type JsonSchema<A = unknown> = Schema.Codec<A, unknown, never, never>;
+interface RunOptions<S extends JsonSchema> {
+  readonly schema: S;
+}
+interface WaitForEventOptions {
+  readonly timeout: Duration.Input;
+  readonly if?: string;
+}
+interface InvokeOptionsBase<F extends InngestFunction.Any> {
+  readonly function: F;
+  readonly user?: Record<string, unknown>;
+  readonly v?: string;
+  readonly timeout?: Duration.Input;
+}
+type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventPayload<F>] extends [never] ? InvokeOptionsBase<F> : InvokeOptionsBase<F> & {
+  readonly data: InngestFunction.EventPayload<F>;
+};
+interface Run {
+  <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
+  <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
+}
+interface Sleep {
+  (id: StepInput, duration: Duration.Input): Effect.Effect<void>;
+}
+interface SleepUntil {
+  (id: StepInput, timestamp: Date | number | string): Effect.Effect<void>;
+}
+interface WaitForEvent {
+  <E extends EventSchema>(id: StepInput, event: E, options: WaitForEventOptions): Effect.Effect<Option.Option<EventType<E>>, StepError>;
+}
+interface Invoke {
+  <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>): Effect.Effect<InngestFunction.Success<F>, StepError>;
+}
+interface OutgoingEvent {
+  readonly name: string;
+  readonly data: unknown;
+}
+interface SendEvent {
+  (id: StepInput, payload: OutgoingEvent | ReadonlyArray<OutgoingEvent>): Effect.Effect<{
+    readonly ids: ReadonlyArray<string>;
+  }, SendEventError, InngestClient>;
+}
+declare namespace StepTools {
+  interface Service {
+    readonly run: Run;
+    readonly sleep: Sleep;
+    readonly sleepUntil: SleepUntil;
+    readonly waitForEvent: WaitForEvent;
+    readonly invoke: Invoke;
+    readonly sendEvent: SendEvent;
+  }
+}
+declare const StepTools_base: Context.ServiceClass<StepTools, "effect-inngest/internal/runtime/StepTools", StepTools.Service>;
+declare class StepTools extends StepTools_base {
+  static readonly make: Effect.Effect<{
+    run: {
+      <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
+      <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
+    };
+    sleep: Sleep;
+    sleepUntil: SleepUntil;
+    waitForEvent: WaitForEvent;
+    invoke: Invoke;
+    sendEvent: SendEvent;
+  }, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
+  static readonly layer: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
+  static readonly live: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | HandlerFiberScope>;
+}
+//#endregion
+export { StepTools };

package/dist/internal/runtime/StepTools.js

@@ -0,0 +1,76 @@
+import { InngestConfig } from "../../Client.js";
+import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
+import { CurrentCheckpoint } from "./CheckpointContext.js";
+import { HandlerFiberScope } from "./HandlerFiberScope.js";
+import { StepCommandBus } from "./StepCommandBus.js";
+import { StepIdentity } from "./StepIdentity.js";
+import { invoke } from "./steps/InvokeStep.js";
+import { sendEvent } from "./steps/SendEventStep.js";
+import { sleep } from "./steps/SleepStep.js";
+import { sleepUntil } from "./steps/SleepUntilStep.js";
+import { run } from "./steps/StepRun.js";
+import { waitForEvent } from "./steps/WaitForEventStep.js";
+import { Context, Effect, Layer, Predicate, pipe } from "effect";
+//#region src/internal/runtime/StepTools.ts
+var StepTools = class extends Context.Service()("effect-inngest/internal/runtime/StepTools") {
+	static make = Effect.gen(function* () {
+		const input = yield* CurrentExecutionInput;
+		const checkpoint = yield* CurrentCheckpoint;
+		const config = yield* InngestConfig;
+		const identity = yield* StepIdentity;
+		const bus = yield* StepCommandBus;
+		const handlerFiberScope = yield* HandlerFiberScope;
+		const runtime = pipe(Context.make(StepIdentity, identity), Context.add(StepCommandBus, bus), Context.add(CurrentExecutionInput, input), Context.add(CurrentCheckpoint, checkpoint), Context.add(InngestConfig, config), Context.add(HandlerFiberScope, handlerFiberScope));
+		function run$1(id, effect, options) {
+			if (Predicate.isNotUndefined(options)) return run({
+				input,
+				id: identity.reserve(id),
+				effect,
+				options
+			}).pipe(Effect.provide(runtime));
+			return run({
+				input,
+				id: identity.reserve(id),
+				effect
+			}).pipe(Effect.provide(runtime));
+		}
+		const sleep$1 = (id, duration) => sleep({
+			input,
+			id: identity.reserve(id),
+			duration
+		}).pipe(Effect.provide(runtime));
+		const sleepUntil$1 = (id, timestamp) => sleepUntil({
+			input,
+			id: identity.reserve(id),
+			timestamp
+		}).pipe(Effect.provide(runtime));
+		const waitForEvent$1 = (id, event, options) => waitForEvent({
+			input,
+			id: identity.reserve(id),
+			event,
+			options
+		}).pipe(Effect.provide(runtime));
+		const invoke$1 = (id, options) => invoke({
+			input,
+			id: identity.reserve(id),
+			options
+		}).pipe(Effect.provide(runtime));
+		const sendEvent$1 = (id, payload) => sendEvent({
+			input,
+			id: identity.reserve(id),
+			payload
+		}).pipe(Effect.provide(runtime));
+		return {
+			run: run$1,
+			sleep: sleep$1,
+			sleepUntil: sleepUntil$1,
+			waitForEvent: waitForEvent$1,
+			invoke: invoke$1,
+			sendEvent: sendEvent$1
+		};
+	});
+	static layer = Layer.effect(this, this.make);
+	static live = this.layer.pipe(Layer.provide(StepCommandBus.layer));
+};
+//#endregion
+export { StepTools };

package/dist/internal/runtime/steps/InvokeStep.js

@@ -0,0 +1,43 @@
+import { InngestDuration } from "../../wire/Duration.js";
+import { InngestConfig } from "../../../Client.js";
+import { StepError } from "../../errors.js";
+import { InvokeFunction } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { decodeMemo } from "../../codec/StepResult.js";
+import { Duration, Effect, Match, Predicate, Schema } from "effect";
+//#region src/internal/runtime/steps/InvokeStep.ts
+const invoke = (args) => Effect.gen(function* () {
+	const config = yield* InngestConfig;
+	const identity = yield* StepIdentity;
+	const bus = yield* StepCommandBus;
+	const info = yield* identity.resolve(args.id);
+	const memo = args.input.memoForStep(info);
+	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeMemo(Schema.toCodecJson(args.options.function.success), info.id)(data)), Match.tag("MemoError", ({ error }) => Effect.fail(StepError.make({
+		stepId: info.id,
+		message: Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed",
+		cause: error
+	}))), Match.tag("MemoTimeout", () => Effect.fail(StepError.make({
+		stepId: info.id,
+		message: "Invoke timed out",
+		noRetry: true
+	}))), Match.tag("MemoInput", () => Effect.succeed(void 0)), Match.tag("MemoNone", () => Effect.gen(function* () {
+		if (!args.input.shouldExecuteStep(info)) return yield* Effect.void;
+		const event = Predicate.hasProperty(args.options, "data") ? args.options.data : void 0;
+		const data = Predicate.isObject(event) && Predicate.hasProperty(event, "data") ? event.data : event;
+		yield* bus.suspend(InvokeFunction.make({
+			info,
+			sequence: args.id.sequence,
+			functionId: `${config.id}-${args.options.function._tag}`,
+			payload: {
+				data,
+				...Predicate.isNotUndefined(args.options.user) ? { user: args.options.user } : {},
+				...Predicate.isNotUndefined(args.options.v) ? { v: args.options.v } : {}
+			},
+			timeout: args.options.timeout ? Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(args.options.timeout)) : void 0
+		}));
+		return yield* Effect.void;
+	})), Match.exhaustive);
+});
+//#endregion
+export { invoke };

package/dist/internal/runtime/steps/SendEventStep.js

@@ -0,0 +1,46 @@
+import { InngestClient } from "../../../Client.js";
+import { SendEventError } from "../../errors.js";
+import { SendEventPlanned, SendEventResult } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { Array, Effect, Match, Predicate, Schema } from "effect";
+//#region src/internal/runtime/steps/SendEventStep.ts
+const SendEventMemoData = Schema.Struct({ ids: Schema.Array(Schema.String) });
+const sendEventDecodeError = (error) => SendEventError.make({
+	message: `Invalid sendEvent memo data: ${Predicate.hasProperty(error, "message") ? String(error.message) : String(error)}`,
+	events: []
+});
+const sendEvent = (args) => Effect.gen(function* () {
+	const identity = yield* StepIdentity;
+	const bus = yield* StepCommandBus;
+	const info = yield* identity.resolve(args.id);
+	const memo = args.input.memoForStep(info);
+	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => Schema.decodeUnknownEffect(SendEventMemoData)(data).pipe(Effect.mapError(sendEventDecodeError))), Match.tag("MemoError", () => Effect.fail(SendEventError.make({
+		message: "SendEvent failed",
+		events: []
+	}))), Match.tag("MemoTimeout", () => Effect.fail(SendEventError.make({
+		message: "SendEvent timed out",
+		events: []
+	}))), Match.tag("MemoInput", () => Effect.succeed({ ids: [] })), Match.tag("MemoNone", () => Effect.gen(function* () {
+		if (!args.input.shouldExecuteStep(info)) return { ids: [] };
+		const planned = SendEventPlanned.make({
+			info,
+			sequence: args.id.sequence
+		});
+		if (args.input.shouldPlanStep(info)) {
+			yield* bus.plan(planned);
+			return { ids: [] };
+		}
+		if (yield* bus.planCheckpointedFork(planned)) return { ids: [] };
+		const events = Array.ensure(args.payload);
+		const result = yield* InngestClient.use((client) => client.sendEvent(events));
+		yield* bus.complete(SendEventResult.make({
+			info,
+			data: { ids: [...result.ids] },
+			rawPayload: Array.isArray(args.payload) ? events : events[0]
+		}));
+		return result;
+	})), Match.exhaustive);
+});
+//#endregion
+export { sendEvent };

package/dist/internal/runtime/steps/SleepStep.js

@@ -0,0 +1,22 @@
+import { InngestDuration } from "../../wire/Duration.js";
+import { Sleep } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { Duration, Effect, Predicate, Schema } from "effect";
+//#region src/internal/runtime/steps/SleepStep.ts
+const sleep = (args) => Effect.gen(function* () {
+	const identity = yield* StepIdentity;
+	const bus = yield* StepCommandBus;
+	const info = yield* identity.resolve(args.id);
+	const memo = args.input.memoForStep(info);
+	if (!Predicate.isTagged(memo, "MemoNone") || !args.input.shouldExecuteStep(info)) return;
+	const command = Sleep.make({
+		info,
+		sequence: args.id.sequence,
+		duration: Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(args.duration))
+	});
+	if (yield* bus.planCheckpointedFork(command)) return;
+	return yield* bus.suspend(command);
+});
+//#endregion
+export { sleep };

package/dist/internal/runtime/steps/SleepUntilStep.js

@@ -0,0 +1,22 @@
+import { Sleep } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { InngestTimestamp } from "../../wire/Timestamp.js";
+import { Effect, Predicate, Schema } from "effect";
+//#region src/internal/runtime/steps/SleepUntilStep.ts
+const sleepUntil = (args) => Effect.gen(function* () {
+	const identity = yield* StepIdentity;
+	const bus = yield* StepCommandBus;
+	const info = yield* identity.resolve(args.id);
+	const memo = args.input.memoForStep(info);
+	if (!Predicate.isTagged(memo, "MemoNone") || !args.input.shouldExecuteStep(info)) return;
+	const command = Sleep.make({
+		info,
+		sequence: args.id.sequence,
+		duration: Schema.decodeUnknownSync(InngestTimestamp)(args.timestamp)
+	});
+	if (yield* bus.planCheckpointedFork(command)) return;
+	return yield* bus.suspend(command);
+});
+//#endregion
+export { sleepUntil };

package/dist/internal/runtime/steps/StepRun.js

@@ -0,0 +1,48 @@
+import { StepRunError, StepRunPlanned, StepRunResult, stepRunFailureForAttempt } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { decodeStepRunMemo, encodeStepRunMemo, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput } from "../../codec/StepResult.js";
+import { Effect, Match, Option, Schema } from "effect";
+//#region src/internal/runtime/steps/StepRun.ts
+function run(args) {
+	const memoCodec = args.options ? Option.some(Schema.toCodecJson(args.options.schema)) : Option.none();
+	return Effect.gen(function* () {
+		const identity = yield* StepIdentity;
+		const bus = yield* StepCommandBus;
+		const info = yield* identity.resolve(args.id);
+		const memo = args.input.memoForStep(info);
+		return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeStepRunMemo(memoCodec, info.id)(data)), Match.tag("MemoError", ({ error }) => failStepRunMemoError(info.id, error)), Match.tag("MemoTimeout", () => failStepRunMemoTimeout(info.id)), Match.tag("MemoInput", ({ input }) => failUnexpectedStepRunMemoInput(info.id, input)), Match.tag("MemoNone", () => Effect.gen(function* () {
+			if (!args.input.shouldExecuteStep(info)) return yield* Effect.void;
+			const planned = StepRunPlanned.make({
+				info,
+				sequence: args.id.sequence
+			});
+			if (args.input.shouldPlanStep(info)) {
+				yield* bus.plan(planned);
+				return yield* Effect.void;
+			}
+			if (yield* bus.planCheckpointedRunBoundary(planned)) return yield* Effect.void;
+			return yield* args.effect.pipe(Effect.matchEffect({
+				onFailure: (error) => bus.fail(stepRunFailureForAttempt({
+					info,
+					error,
+					attempt: args.input.run.attempt,
+					maxAttempts: args.input.run.maxAttempts
+				})),
+				onSuccess: (value) => Effect.gen(function* () {
+					const data = yield* encodeStepRunMemo(memoCodec, info.id)(value);
+					yield* bus.complete(StepRunResult.make({
+						info,
+						data
+					}));
+					return yield* decodeStepRunMemo(memoCodec, info.id)(data);
+				})
+			}), Effect.catchDefect((defect) => bus.fail(StepRunError.make({
+				info,
+				error: defect
+			}))));
+		})), Match.exhaustive);
+	});
+}
+//#endregion
+export { run };

package/dist/internal/runtime/steps/WaitForEventStep.js

@@ -0,0 +1,27 @@
+import { InngestDuration } from "../../wire/Duration.js";
+import { WaitForEvent } from "../../domain/StepCommand.js";
+import { StepCommandBus } from "../StepCommandBus.js";
+import { StepIdentity } from "../StepIdentity.js";
+import { failMemoDecode, mapMemoDecodeError } from "../../codec/StepResult.js";
+import { decodeMemoData } from "../../codec/EventPayload.js";
+import { Duration, Effect, Match, Option, Schema } from "effect";
+//#region src/internal/runtime/steps/WaitForEventStep.ts
+const waitForEvent = (args) => Effect.gen(function* () {
+	const identity = yield* StepIdentity;
+	const bus = yield* StepCommandBus;
+	const info = yield* identity.resolve(args.id);
+	const memo = args.input.memoForStep(info);
+	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeMemoData(args.event)(data).pipe(mapMemoDecodeError(info.id), Effect.map(Option.some))), Match.tag("MemoTimeout", () => Effect.succeed(Option.none())), Match.tag("MemoError", ({ error }) => failMemoDecode(info.id, error)), Match.tag("MemoInput", ({ input }) => failMemoDecode(info.id, input)), Match.tag("MemoNone", () => Effect.gen(function* () {
+		if (!args.input.shouldExecuteStep(info)) return Option.none();
+		yield* bus.suspend(WaitForEvent.make({
+			info,
+			sequence: args.id.sequence,
+			event: args.event.identifier,
+			timeout: Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(args.options.timeout)),
+			if: args.options.if
+		}));
+		return Option.none();
+	})), Match.exhaustive);
+});
+//#endregion
+export { waitForEvent };

package/dist/internal/serve/HttpApp.js

@@ -0,0 +1,71 @@
+import { Headers } from "../protocol.js";
+import { SignatureLive } from "./Signature.js";
+import { handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody } from "../handler.js";
+import { Effect, Option, Predicate, Schema } from "effect";
+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";
+Schema.TaggedErrorClass()("MethodNotAllowed", { method: Schema.String });
+Schema.TaggedErrorClass()("InvalidQueryParams", { message: Schema.String });
+const toHttpApp = (group) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const method = request.method;
+	const requestUrl = Option.match(HttpServerRequest.toURL(request), {
+		onNone: () => request.url,
+		onSome: (url) => url.toString()
+	});
+	if (method === "GET") {
+		const result = yield* handleIntrospection(group, requestUrl);
+		return yield* HttpServerResponse.json(result.body, {
+			status: result.status,
+			headers: result.headers
+		});
+	}
+	if (method === "PUT") {
+		const result = yield* handleRegistration(group, requestUrl);
+		return yield* HttpServerResponse.json(result.body, {
+			status: result.status,
+			headers: result.headers
+		});
+	}
+	if (method === "POST") {
+		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* Schema.decodeUnknownEffect(ExecuteParamsSchema)(UrlParams.fromInput(url.searchParams)).pipe(Effect.catch((error) => Effect.fail(HttpServerResponse.jsonUnsafe({ error: `Missing or invalid fnId query parameter: ${String(error)}` }, {
+			status: 400,
+			headers: { [Headers.NoRetry]: "true" }
+		}))));
+		const body = yield* verifyAndParseRequestBody(request).pipe(Effect.provide(SignatureLive), Effect.catch((error) => Effect.fail(HttpServerResponse.jsonUnsafe({ error: error.message }, {
+			status: Predicate.isTagged(error, "SignatureError") ? 401 : 400,
+			headers: { [Headers.NoRetry]: "true" }
+		}))));
+		const result = yield* handleExecution({
+			group,
+			fnId: params.fnId,
+			urlStepId: params.stepId,
+			body
+		});
+		return yield* HttpServerResponse.json(result.body, {
+			status: result.status,
+			headers: result.headers
+		});
+	}
+	return yield* HttpServerResponse.json({ error: `Method ${method} not allowed` }, { status: 405 });
+}).pipe(Effect.catchCause((cause) => HttpServerResponse.json({
+	error: "Internal server error",
+	cause: String(cause)
+}, { status: 500 }).pipe(Effect.orDie)));
+const toWebHandler = (args) => HttpEffect.toWebHandlerLayer(toHttpApp(args.group), args.options.layer);
+//#endregion
+export { toHttpApp, toWebHandler };

package/dist/internal/serve/Request.js

@@ -0,0 +1,23 @@
+import { Headers as Headers$1 } from "../protocol.js";
+import { Signature, SignatureHeader, SignedPayload } from "./Signature.js";
+import { Effect, Function, Option, Schema } from "effect";
+import "effect/unstable/http/HttpServerRequest";
+import * as Headers from "effect/unstable/http/Headers";
+//#region src/internal/serve/Request.ts
+const verifySignature = Function.dual(2, (body, request) => Effect.gen(function* () {
+	const sig = yield* Signature;
+	const signature = yield* Option.match(Headers.get(request.headers, Headers$1.Signature), {
+		onNone: () => Effect.succeed(Option.none()),
+		onSome: (header) => SignatureHeader.decode(header).pipe(Effect.map(Option.some))
+	});
+	yield* sig.verify(SignedPayload.make({
+		body,
+		signature
+	}));
+}));
+const schemaBodyJson = (schema) => (body) => {
+	const bodyText = new TextDecoder().decode(body);
+	return Schema.decodeUnknownEffect(Schema.fromJsonString(schema))(bodyText);
+};
+//#endregion
+export { schemaBodyJson, verifySignature };

package/dist/internal/serve/Signature.d.ts

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer, Option, Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/internal/serve/Signature.d.ts
+declare const SignatureError_base: Schema.Class<SignatureError, Schema.TaggedStruct<"SignatureError", {
+  readonly reason: Schema.Literals<readonly ["missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"]>;
+  readonly message: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
+declare class SignatureError extends SignatureError_base {}
+//#endregion
+export { SignatureError };