effect-inngest 0.2.0-beta.0 → 0.3.0-beta.0

package/dist/Events.d.ts

@@ -1,4 +1,5 @@
-import * as Schema from "effect/Schema";
+import { EventDefinition } from "./Event.js";
+import { Schema } from "effect";
 
 //#region src/Events.d.ts
 declare namespace Events_d_exports {
@@ -15,71 +16,67 @@ declare const JsonError_base: Schema.Class<JsonError, Schema.Struct<{
  * @since 0.1.0
  */
 declare class JsonError extends JsonError_base {}
-declare const FunctionFailed_base: Schema.Class<FunctionFailed, Schema.TaggedStruct<"inngest/function.failed", {
-  readonly function_id: Schema.String;
-  readonly run_id: Schema.String;
-  readonly error: typeof JsonError;
-  readonly event: Schema.$Record<Schema.String, Schema.Unknown>;
-}>, {}>;
 /**
  * Sent when a function fails after exhausting all retries.
  * Trigger on this to handle failures (e.g., alerting, cleanup).
  * @since 0.1.0
  */
-declare class FunctionFailed extends FunctionFailed_base {}
-declare const FunctionFinishedError_base: Schema.Class<FunctionFinishedError, Schema.TaggedStruct<"inngest/function.finished", {
+declare const FunctionFailed: EventDefinition<"inngest/function.failed", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly error: typeof JsonError;
+  readonly event: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>;
+declare const FunctionFinishedError: EventDefinition<"inngest/function.finished", Schema.Struct<{
   readonly function_id: Schema.String;
   readonly run_id: Schema.String;
   readonly correlation_id: Schema.optional<Schema.String>;
   readonly error: typeof JsonError;
-}>, {}>;
-/**
- * Sent when a function finishes with an error.
- * @since 0.1.0
- */
-declare class FunctionFinishedError extends FunctionFinishedError_base {}
-declare const FunctionFinishedSuccess_base: Schema.Class<FunctionFinishedSuccess, Schema.TaggedStruct<"inngest/function.finished", {
+}>>;
+declare const FunctionFinishedSuccess: EventDefinition<"inngest/function.finished", Schema.Struct<{
   readonly function_id: Schema.String;
   readonly run_id: Schema.String;
   readonly correlation_id: Schema.optional<Schema.String>;
   readonly result: Schema.Unknown;
-}>, {}>;
-/**
- * Sent when a function finishes successfully.
- * @since 0.1.0
- */
-declare class FunctionFinishedSuccess extends FunctionFinishedSuccess_base {}
+}>>;
 /**
  * Union of both FunctionFinished variants.
  * @since 0.1.0
  */
-declare const FunctionFinished: Schema.Union<readonly [typeof FunctionFinishedError, typeof FunctionFinishedSuccess]>;
-type FunctionFinished = typeof FunctionFinished.Type;
-declare const FunctionCancelled_base: Schema.Class<FunctionCancelled, Schema.TaggedStruct<"inngest/function.cancelled", {
+declare const FunctionFinished: EventDefinition<"inngest/function.finished", Schema.Union<readonly [Schema.Struct<{
   readonly function_id: Schema.String;
   readonly run_id: Schema.String;
   readonly correlation_id: Schema.optional<Schema.String>;
-}>, {}>;
+  readonly error: typeof JsonError;
+}>, Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly result: Schema.Unknown;
+}>]>>;
+type FunctionFinished = typeof FunctionFinished.Type;
 /**
  * Sent when a function is cancelled.
  * @since 0.1.0
  */
-declare class FunctionCancelled extends FunctionCancelled_base {}
-declare const FunctionInvoked_base: Schema.Class<FunctionInvoked, Schema.TaggedStruct<"inngest/function.invoked", {
-  readonly data: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
-}>, {}>;
+declare const FunctionCancelled: EventDefinition<"inngest/function.cancelled", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+}>>;
 /**
  * Sent when a function is invoked via step.invoke().
  * @since 0.1.0
  */
-declare class FunctionInvoked extends FunctionInvoked_base {}
-declare const ScheduledTimer_base: Schema.Class<ScheduledTimer, Schema.TaggedStruct<"inngest/scheduled.timer", {
-  readonly cron: Schema.String;
-}>, {}>;
+declare const FunctionInvoked: EventDefinition<"inngest/function.invoked", Schema.StructWithRest<Schema.Struct<{
+  readonly _inngest: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
 /**
  * Sent when a cron trigger fires.
  * @since 0.1.0
  */
-declare class ScheduledTimer extends ScheduledTimer_base {}
+declare const ScheduledTimer: EventDefinition<"inngest/scheduled.timer", Schema.Struct<{
+  readonly cron: Schema.String;
+}>>;
 //#endregion
 export { Events_d_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Events.js

@@ -1,5 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import * as Schema from "effect/Schema";
+import { make } from "./Event.js";
+import { Schema } from "effect";
 //#region src/Events.ts
 /**
 * Internal Inngest events that the platform sends automatically.
@@ -31,55 +32,57 @@ var JsonError = class extends Schema.Class("JsonError")({
 * Trigger on this to handle failures (e.g., alerting, cleanup).
 * @since 0.1.0
 */
-var FunctionFailed = class extends Schema.TaggedClass()("inngest/function.failed", {
+const FunctionFailed = make("inngest/function.failed", Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	error: JsonError,
 	event: Schema.Record(Schema.String, Schema.Unknown)
-}) {};
+}));
 /**
 * Sent when a function finishes with an error.
 * @since 0.1.0
 */
-var FunctionFinishedError = class extends Schema.TaggedClass()("inngest/function.finished", {
+const FunctionFinishedErrorData = Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String),
 	error: JsonError
-}) {};
+});
+const FunctionFinishedError = make("inngest/function.finished", FunctionFinishedErrorData);
 /**
 * Sent when a function finishes successfully.
 * @since 0.1.0
 */
-var FunctionFinishedSuccess = class extends Schema.TaggedClass()("inngest/function.finished", {
+const FunctionFinishedSuccessData = Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String),
 	result: Schema.Unknown
-}) {};
+});
+const FunctionFinishedSuccess = make("inngest/function.finished", FunctionFinishedSuccessData);
 /**
 * Union of both FunctionFinished variants.
 * @since 0.1.0
 */
-const FunctionFinished = Schema.Union([FunctionFinishedError, FunctionFinishedSuccess]);
+const FunctionFinished = make("inngest/function.finished", Schema.Union([FunctionFinishedErrorData, FunctionFinishedSuccessData]));
 /**
 * Sent when a function is cancelled.
 * @since 0.1.0
 */
-var FunctionCancelled = class extends Schema.TaggedClass()("inngest/function.cancelled", {
+const FunctionCancelled = make("inngest/function.cancelled", Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String)
-}) {};
+}));
 /**
 * Sent when a function is invoked via step.invoke().
 * @since 0.1.0
 */
-var FunctionInvoked = class extends Schema.TaggedClass()("inngest/function.invoked", { data: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)) }) {};
+const FunctionInvoked = make("inngest/function.invoked", Schema.StructWithRest(Schema.Struct({ _inngest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)) }), [Schema.Record(Schema.String, Schema.Unknown)]));
 /**
 * Sent when a cron trigger fires.
 * @since 0.1.0
 */
-var ScheduledTimer = class extends Schema.TaggedClass()("inngest/scheduled.timer", { cron: Schema.String }) {};
+const ScheduledTimer = make("inngest/scheduled.timer", Schema.Struct({ cron: Schema.String }));
 //#endregion
 export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Function.d.ts

@@ -1,4 +1,5 @@
-import { CheckpointingOption } from "./internal/checkpoint.js";
+import { CheckpointingOption } from "./internal/checkpoint/Config.js";
+import { EventDefinition, EventType } from "./Event.js";
 import { Duration, Schema } from "effect";
 import { Pipeable } from "effect/Pipeable";
 
@@ -16,9 +17,7 @@ declare const TypeId: unique symbol;
  * @category type ids
  */
 type TypeId = typeof TypeId;
-type EventSchema = Schema.Top & {
-  readonly identifier: string;
-};
+type EventSchema = EventDefinition;
 /**
  * An event-based trigger configuration.
  *
@@ -344,7 +343,11 @@ interface FunctionRegistration {
     readonly period: string;
     readonly timeout?: string;
   };
-  readonly concurrency?: ReadonlyArray<{
+  readonly concurrency?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  } | ReadonlyArray<{
     readonly key?: string;
     readonly limit: number;
     readonly scope?: string;
@@ -374,7 +377,7 @@ interface FunctionRegistration {
  * @since 0.1.0
  * @category models
  */
-interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Top, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
+interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Codec<unknown, unknown, never, never>, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
   readonly [TypeId]: TypeId;
   readonly _tag: Tag;
   readonly key: string;
@@ -388,12 +391,16 @@ interface InngestFunction<Tag extends string, Triggers extends Trigger, Success
  * @category models
  */
 declare namespace InngestFunction {
-  type Any = InngestFunction<string, Trigger, Schema.Top, FunctionOptions>;
+  type Any = InngestFunction<string, Trigger, Schema.Codec<any, any, never, never>, FunctionOptions>;
   type Tag<F> = F extends InngestFunction<infer T, any, any, any> ? T : never;
   type Triggers<F> = F extends InngestFunction<any, infer T, any, any> ? T : never;
   type Events<F> = F extends InngestFunction<any, infer T, any, any> ? (T extends EventTrigger<infer E> ? E : never) : never;
-  type EventType<F> = F extends InngestFunction<any, infer T, any, any> ? T extends EventTrigger<infer E> ? Schema.Schema.Type<E> : never : never;
-  type Success<F> = F extends InngestFunction<any, any, infer S, any> ? Schema.Schema.Type<S> : never;
+  type EventPayload<F> = EventType<Events<F>>;
+  type EventType<F> = Options<F> extends {
+    readonly batchEvents: BatchEventsOption;
+  } ? ReadonlyArray<EventPayload<F>> : EventPayload<F>;
+  type SuccessSchema<F> = F extends InngestFunction<any, any, infer S, any> ? S : never;
+  type Success<F> = Schema.Schema.Type<SuccessSchema<F>>;
   type Options<F> = F extends InngestFunction<any, any, any, infer O> ? O : never;
 }
 type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger> ? T[number] : T;
@@ -430,7 +437,7 @@ type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger
  * })
  * ```
  */
-declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Top, const O extends FunctionOptions = {}>(tag: Tag, options: {
+declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Codec<unknown, unknown, never, never>, const O extends FunctionOptions = {}>(tag: Tag, options: {
   readonly trigger: T;
   readonly success: S;
 } & O): InngestFunction<Tag, NormalizeTriggers<T>, S, O>;

package/dist/Function.js

@@ -1,7 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { timeStr } from "./internal/helpers.js";
-import { resolveConfig, toRegistration } from "./internal/checkpoint.js";
-import { Array, Predicate } from "effect";
+import { InngestDuration } from "./internal/wire/Duration.js";
+import { resolveConfig, toRegistration } from "./internal/checkpoint/Config.js";
+import { Array, Duration, Option, Predicate, Schema } from "effect";
 import { pipeArguments } from "effect/Pipeable";
 //#region src/Function.ts
 /**
@@ -17,6 +17,7 @@ var Function_exports = /* @__PURE__ */ __exportAll({
 */
 const TypeId = Symbol.for("effect-inngest/Function");
 const isEventTrigger = (t) => Predicate.hasProperty(t, "event");
+const encodeDuration = (input) => Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(input));
 const Proto = {
 	[TypeId]: TypeId,
 	pipe() {
@@ -33,33 +34,35 @@ const Proto = {
 		const cancel = opts.cancelOn?.map((c) => ({
 			event: c.event,
 			if: c.if,
-			timeout: c.timeout ? timeStr(c.timeout) : void 0
+			timeout: c.timeout ? encodeDuration(c.timeout) : void 0
 		}));
 		const timeouts = opts.timeouts?.start || opts.timeouts?.finish ? {
-			start: opts.timeouts.start ? timeStr(opts.timeouts.start) : void 0,
-			finish: opts.timeouts.finish ? timeStr(opts.timeouts.finish) : void 0
+			start: opts.timeouts.start ? encodeDuration(opts.timeouts.start) : void 0,
+			finish: opts.timeouts.finish ? encodeDuration(opts.timeouts.finish) : void 0
 		} : void 0;
 		const rateLimit = opts.rateLimit ? {
 			key: opts.rateLimit.key,
 			limit: opts.rateLimit.limit,
-			period: timeStr(opts.rateLimit.period)
+			period: encodeDuration(opts.rateLimit.period)
 		} : void 0;
 		const throttle = opts.throttle ? {
 			key: opts.throttle.key,
 			limit: opts.throttle.limit,
-			period: timeStr(opts.throttle.period),
+			period: encodeDuration(opts.throttle.period),
 			burst: opts.throttle.burst
 		} : void 0;
 		const debounce = opts.debounce ? {
 			key: opts.debounce.key,
-			period: timeStr(opts.debounce.period),
-			timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : void 0
+			period: encodeDuration(opts.debounce.period),
+			timeout: opts.debounce.timeout ? encodeDuration(opts.debounce.timeout) : void 0
 		} : void 0;
-		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
-		})) : void 0;
+		const serializeConcurrencyOption = (option) => ({
+			key: option.key,
+			limit: option.limit,
+			scope: option.scope
+		});
+		const isConcurrencyOptions = (value) => Array.isArray(value);
+		const concurrency = Option.fromNullishOr(opts.concurrency).pipe(Option.map((value) => Predicate.isNumber(value) ? { limit: value } : isConcurrencyOptions(value) ? Array.map(value, serializeConcurrencyOption) : serializeConcurrencyOption(value)), Option.getOrUndefined);
 		const priority = opts.priority ? { run: opts.priority.run } : void 0;
 		const singleton = opts.singleton ? {
 			key: opts.singleton.key,
@@ -67,11 +70,12 @@ const Proto = {
 		} : void 0;
 		const batchEvents = opts.batchEvents ? {
 			maxSize: opts.batchEvents.maxSize,
-			timeout: timeStr(opts.batchEvents.timeout),
+			timeout: encodeDuration(opts.batchEvents.timeout),
 			key: opts.batchEvents.key
 		} : void 0;
 		const idempotency = opts.idempotency;
-		const resolvedCheckpoint = opts.checkpointing !== void 0 ? resolveConfig(opts.checkpointing, void 0) : void 0;
+		const retries = Predicate.isNotUndefined(opts.retries) ? { attempts: opts.retries } : void 0;
+		const resolvedCheckpoint = Predicate.isNotUndefined(opts.checkpointing) ? 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);
@@ -88,7 +92,7 @@ const Proto = {
 					type: "http",
 					url: stepUrl.href
 				},
-				retries: { attempts: opts.retries ?? 3 }
+				retries
 			} },
 			cancel: cancel && cancel.length > 0 ? cancel : void 0,
 			timeouts,

package/dist/Group.d.ts

@@ -1,12 +1,10 @@
 import { InngestClient } from "./Client.js";
 import { InngestFunction } from "./Function.js";
-import { HandlerContext } from "./internal/step.js";
-import * as Effect from "effect/Effect";
+import { HandlerContext } from "./internal/runtime/HandlerContext.js";
+import { Context, Effect, Layer } from "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";
+import * as _$effect_unstable_http_HttpServerRequest0 from "effect/unstable/http/HttpServerRequest";
+import * as _$effect_unstable_http_HttpServerResponse0 from "effect/unstable/http/HttpServerResponse";
 
 //#region src/Group.d.ts
 declare namespace Group_d_exports {
@@ -65,7 +63,7 @@ interface Handler<Tag extends string> {
  * @since 0.1.0
  * @category models
  */
-type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer _Tag, infer _Triggers, infer _Success> ? Handler<_Tag> : never;
+type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer Tag, infer _Triggers, infer _Success> ? Handler<Tag> : never;
 /**
  * @since 0.1.0
  * @category models
@@ -73,6 +71,10 @@ type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer
 interface InngestGroup<Fns extends InngestFunction.Any> {
   readonly [TypeId]: TypeId;
   readonly functions: ReadonlyMap<string, Fns>;
+  /**
+   * Implement all handlers for the functions in this group, returning a context object.
+   */
+  readonly toHandlers: <H extends HandlersFrom<Fns>>(handlers: H) => Effect.Effect<Context.Context<ToHandler<Fns>>, never, HandlersRequirements<H>>;
   /**
    * Implement all handlers for the functions in this group.
    */
@@ -81,6 +83,14 @@ interface InngestGroup<Fns extends InngestFunction.Any> {
    * Implement a single handler from the group.
    */
   readonly toLayerHandler: <Tag extends InngestFunction.Tag<Fns>, H extends HandlerFrom<Fns, Tag>>(tag: Tag, handler: H) => Layer.Layer<Handler<Tag>, never, HandlerRequirements<H>>;
+  /**
+   * Retrieve a handler for a specific function in the group.
+   */
+  readonly accessHandler: <Tag extends InngestFunction.Tag<Fns>>(tag: Tag) => Effect.Effect<(context: HandlerContext<Extract<Fns, {
+    readonly _tag: Tag;
+  }>>) => Effect.Effect<InngestFunction.Success<Extract<Fns, {
+    readonly _tag: Tag;
+  }>>, unknown>, never, Handler<Tag>>;
 }
 /**
  * @since 0.1.0
@@ -117,7 +127,7 @@ declare const make: <Fns extends ReadonlyArray<InngestFunction.Any>>(...fns: Fns
  * )
  * ```
  */
-declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, InngestClient | HttpClient.HttpClient | HttpServerRequest.HttpServerRequest>;
+declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$effect_unstable_http_HttpServerResponse0.HttpServerResponse, never, InngestClient | HttpClient.HttpClient | _$effect_unstable_http_HttpServerRequest0.HttpServerRequest>;
 /**
  * Create a standalone web handler from an InngestGroup.
  *

package/dist/Group.js

@@ -1,18 +1,8 @@
 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 Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
+import "./internal/runtime/HandlerContext.js";
+import { toHttpApp as toHttpApp$1, toWebHandler as toWebHandler$1 } from "./internal/serve/HttpApp.js";
+import { Context, Effect, Layer } 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";
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
 //#region src/Group.ts
 var Group_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
@@ -27,20 +17,24 @@ var Group_exports = /* @__PURE__ */ __exportAll({
 const TypeId = Symbol.for("effect-inngest/Group");
 const Proto = {
 	[TypeId]: TypeId,
-	toLayer(handlers) {
+	toHandlers(handlers) {
 		const functions = this.functions;
-		return Layer.effectContext(Effect.gen(function* () {
+		return Effect.gen(function* () {
 			const context = yield* Effect.context();
 			const contextMap = /* @__PURE__ */ new Map();
 			for (const [tag, handler] of Object.entries(handlers)) {
 				const fn = functions.get(tag);
 				contextMap.set(fn.key, {
+					tag: fn._tag,
 					handler,
 					context
 				});
 			}
 			return Context.makeUnsafe(contextMap);
-		}));
+		});
+	},
+	toLayer(handlers) {
+		return Layer.effectContext(this.toHandlers(handlers));
 	},
 	toLayerHandler(tag, handler) {
 		const fn = this.functions.get(tag);
@@ -48,11 +42,19 @@ const Proto = {
 			const context = yield* Effect.context();
 			const contextMap = /* @__PURE__ */ new Map();
 			contextMap.set(fn.key, {
+				tag: fn._tag,
 				handler,
 				context
 			});
 			return Context.makeUnsafe(contextMap);
 		}));
+	},
+	accessHandler(tag) {
+		return Effect.contextWith((parentContext) => {
+			const fn = this.functions.get(tag);
+			const { handler, context } = parentContext.mapUnsafe.get(fn.key);
+			return Effect.succeed((handlerContext) => Effect.provide(handler(handlerContext), context));
+		});
 	}
 };
 /**
@@ -86,57 +88,8 @@ const make = (...fns) => {
 * ```
 */
 const toHttpApp = Effect.fn("InngestGroup.toHttpApp")(function* (group) {
-	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(() => 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.catch((error) => Effect.fail(HttpServerResponse.jsonUnsafe({ error: error.message }, {
-			status: error._tag === "SignatureError" ? 401 : 400,
-			headers: { [Headers.NoRetry]: "true" }
-		}))));
-		const result = yield* handleExecution(group, params.fnId, 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 });
-}, Effect.catchCause((cause) => HttpServerResponse.json({
-	error: "Internal server error",
-	cause: String(cause)
-}, { status: 500 }).pipe(Effect.orDie)));
+	return yield* toHttpApp$1(group);
+});
 /**
 * Create a standalone web handler from an InngestGroup.
 *
@@ -161,6 +114,9 @@ const toHttpApp = Effect.fn("InngestGroup.toHttpApp")(function* (group) {
 * process.on("SIGTERM", dispose)
 * ```
 */
-const toWebHandler = (group, options) => HttpEffect.toWebHandlerLayer(toHttpApp(group), options.layer);
+const toWebHandler = (group, options) => toWebHandler$1({
+	group,
+	options
+});
 //#endregion
 export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/dist/HttpApi.d.ts

@@ -1,14 +1,13 @@
 import { InngestClient } from "./Client.js";
 import { InngestGroup } from "./Group.js";
-import { SignatureError } from "./internal/signature.js";
+import { SignatureError } from "./internal/serve/Signature.js";
 import { InvalidRequestError } from "./internal/handler.js";
-import * as Schema from "effect/Schema";
+import { Layer, Schema } from "effect";
 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";
+import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/HttpApi.d.ts
 declare namespace HttpApi_d_exports {
@@ -22,7 +21,7 @@ declare const InngestApiGroup_base: HttpApiGroup.HttpApiGroup<"inngest", HttpApi
   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 has_signing_key_fallback: Schema.optional<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>>;
@@ -43,11 +42,12 @@ declare const InngestApiGroup_base: HttpApiGroup.HttpApiGroup<"inngest", HttpApi
   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 has_signing_key_fallback: Schema.optional<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 authentication_succeeded: Schema.optional<Schema.Union<readonly [Schema.Literal<false>, Schema.Null]>>;
+  readonly capabilities: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
   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;

package/dist/HttpApi.js

@@ -1,13 +1,10 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { IntrospectionResponse, RegisterResponse } from "./internal/protocol.js";
-import { SignatureError, SignatureLive } from "./internal/signature.js";
+import { SignatureError, SignatureLive } from "./internal/serve/Signature.js";
 import { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody } from "./internal/handler.js";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
+import { Effect, Layer, Option, Schema } from "effect";
 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";
@@ -55,7 +52,12 @@ const layerGroup = (api, group) => {
 		onSome: (url) => url.toString()
 	});
 	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)));
+		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,
+			fnId: query.fnId,
+			urlStepId: query.stepId,
+			body: payload
+		})), Effect.map((r) => r.body)));
 	})).pipe(Layer.provide(SignatureLive));
 };
 //#endregion

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { Client_d_exports } from "./Client.js";
+import { Event_d_exports } from "./Event.js";
 import { Events_d_exports } from "./Events.js";
 import { Function_d_exports } from "./Function.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Group_d_exports } from "./Group.js";
 import { HttpApi_d_exports } from "./HttpApi.js";
-export { Client_d_exports as InngestClient, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+export { Client_d_exports as InngestClient, Event_d_exports as InngestEvent, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/index.js

@@ -1,7 +1,8 @@
 import { Function_exports } from "./Function.js";
+import { Event_exports } from "./Event.js";
 import { Client_exports } from "./Client.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
+import { Events_exports } from "./Events.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, Event_exports as InngestEvent, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/internal/checkpoint/Config.d.ts

@@ -0,0 +1,10 @@
+import { Duration } from "effect";
+
+//#region src/internal/checkpoint/Config.d.ts
+type CheckpointingOption = boolean | {
+  readonly bufferedSteps?: number;
+  readonly maxInterval?: Duration.Input;
+  readonly maxRuntime?: Duration.Input;
+};
+//#endregion
+export { CheckpointingOption };