effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/Group.d.ts

@@ -1,11 +1,10 @@
 import { InngestClient } from "./Client.js";
 import { InngestFunction } from "./Function.js";
-import { HandlerContext } from "./internal/step.js";
-import * as HttpApp from "@effect/platform/HttpApp";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
+import { HandlerContext } from "./internal/runtime/HandlerContext.js";
+import { Context, Effect, Layer } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+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 {
@@ -64,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
@@ -72,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.
    */
@@ -80,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
@@ -116,7 +127,7 @@ declare const make: <Fns extends ReadonlyArray<InngestFunction.Any>>(...fns: Fns
  * )
  * ```
  */
-declare const toHttpApp: (group: InngestGroup.Any) => HttpApp.Default<never, InngestClient | HttpClient.HttpClient>;
+declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$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,22 +1,9 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
-import { Headers } from "./internal/protocol.js";
-import { SignatureLive } from "./internal/signature.js";
-import { handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody } from "./internal/handler.js";
-import * as HttpApp from "@effect/platform/HttpApp";
-import "@effect/platform/HttpClient";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as UrlParams from "@effect/platform/UrlParams";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+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";
 //#region src/Group.ts
-/**
-* @since 0.1.0
-*/
 var Group_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
 	make: () => make,
@@ -30,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.unsafeMake(contextMap);
-		}));
+			return Context.makeUnsafe(contextMap);
+		});
+	},
+	toLayer(handlers) {
+		return Layer.effectContext(this.toHandlers(handlers));
 	},
 	toLayerHandler(tag, handler) {
 		const fn = this.functions.get(tag);
@@ -51,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.unsafeMake(contextMap);
+			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));
+		});
 	}
 };
 /**
@@ -88,52 +87,9 @@ const make = (...fns) => {
 * )
 * ```
 */
-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 = Option.getOrThrow(HttpServerRequest.toURL(request));
-		const ExecuteParams = Schema.Struct({
-			fnId: Schema.String,
-			stepId: Schema.optional(Schema.String)
-		});
-		const params = yield* UrlParams.schemaStruct(ExecuteParams)(UrlParams.fromInput(url.searchParams)).pipe(Effect.catchAll(() => Effect.fail(HttpServerResponse.unsafeJson({ error: "Missing or invalid fnId query parameter" }, {
-			status: 400,
-			headers: { [Headers.NoRetry]: "true" }
-		}))));
-		const body = yield* verifyAndParseRequestBody(request).pipe(Effect.provide(SignatureLive), Effect.catchAll((error) => Effect.fail(HttpServerResponse.unsafeJson({ error: error.message }, {
-			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 });
-}).pipe(Effect.catchAllCause((cause) => HttpServerResponse.json({
-	error: "Internal server error",
-	cause: String(cause)
-}, { status: 500 }).pipe(Effect.orDie)));
+const toHttpApp = Effect.fn("InngestGroup.toHttpApp")(function* (group) {
+	return yield* toHttpApp$1(group);
+});
 /**
 * Create a standalone web handler from an InngestGroup.
 *
@@ -158,7 +114,9 @@ const toHttpApp = (group) => Effect.gen(function* () {
 * process.on("SIGTERM", dispose)
 * ```
 */
-const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));
-
+const toWebHandler = (group, options) => toWebHandler$1({
+	group,
+	options
+});
 //#endregion
-export { Group_exports, TypeId, make, toHttpApp, toWebHandler };
+export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/dist/HttpApi.d.ts

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

package/dist/HttpApi.js

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

package/dist/_virtual/_rolldown/runtime.js

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

package/dist/index.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,8 +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 };

package/dist/internal/checkpoint/Config.js

@@ -0,0 +1,29 @@
+import { InngestDuration } from "../wire/Duration.js";
+import { Duration, Predicate, Schema } from "effect";
+//#region src/internal/checkpoint/Config.ts
+const DEFAULTS = {
+	bufferedSteps: 1,
+	maxInterval: Duration.millis(0),
+	maxRuntime: Duration.seconds(10)
+};
+const normalize = (option) => ({
+	bufferedSteps: option.bufferedSteps ?? DEFAULTS.bufferedSteps,
+	maxInterval: Predicate.isNotUndefined(option.maxInterval) ? Duration.fromInputUnsafe(option.maxInterval) : DEFAULTS.maxInterval,
+	maxRuntime: Predicate.isNotUndefined(option.maxRuntime) ? Duration.fromInputUnsafe(option.maxRuntime) : DEFAULTS.maxRuntime
+});
+const resolveConfig = (fnLevel, clientLevel) => {
+	if (fnLevel === false) return;
+	if (fnLevel === true) return DEFAULTS;
+	if (Predicate.isNotUndefined(fnLevel)) return normalize(fnLevel);
+	if (clientLevel === false) return;
+	if (clientLevel === true) return DEFAULTS;
+	if (Predicate.isNotUndefined(clientLevel)) return normalize(clientLevel);
+	return DEFAULTS;
+};
+const toRegistration = (cfg) => ({
+	batch_steps: cfg.bufferedSteps,
+	batch_interval: Schema.encodeSync(InngestDuration)(cfg.maxInterval),
+	max_runtime: Schema.encodeSync(InngestDuration)(cfg.maxRuntime)
+});
+//#endregion
+export { resolveConfig, toRegistration };

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

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/internal/checkpoint/Error.d.ts
+declare const CheckpointApiError_base: Schema.Class<CheckpointApiError, Schema.TaggedStruct<"CheckpointApiError", {
+  readonly message: Schema.String;
+  readonly status: Schema.optionalKey<Schema.Number>;
+}>, _$effect_Cause0.YieldableError>;
+declare class CheckpointApiError extends CheckpointApiError_base {}
+//#endregion
+export { CheckpointApiError };

package/dist/internal/checkpoint/Error.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+//#region src/internal/checkpoint/Error.ts
+var CheckpointApiError = class extends Schema.TaggedErrorClass()("CheckpointApiError", {
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Number)
+}) {};
+//#endregion
+export { CheckpointApiError };

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

@@ -0,0 +1 @@
+import { Effect } from "effect";

package/dist/internal/checkpoint/State.js

@@ -0,0 +1,54 @@
+import { Array, Clock, Duration, Effect, Option, Ref, Result } from "effect";
+//#region src/internal/checkpoint/State.ts
+const make = (args) => Effect.sync(() => {
+	const buffer = Ref.makeUnsafe(Array.empty());
+	const plannedBuffer = Ref.makeUnsafe(Array.empty());
+	const intervalStartedAt = Ref.makeUnsafe(Option.none());
+	const runtimeExceeded = Ref.makeUnsafe(false);
+	const maxIntervalMs = Duration.toMillis(args.config.maxInterval);
+	const flushInner = Effect.gen(function* () {
+		const steps = yield* Ref.modify(buffer, (current) => [current, Array.empty()]);
+		if (steps.length === 0) return;
+		const result = yield* Effect.result(args.checkpointAsync(steps));
+		if (Result.isFailure(result)) {
+			yield* Ref.update(buffer, (current) => [...steps, ...current]);
+			return;
+		}
+		yield* Ref.set(intervalStartedAt, Option.none());
+	});
+	const record = (op) => Effect.gen(function* () {
+		const len = yield* Ref.modify(buffer, (current) => {
+			const next = [...current, op];
+			return [next.length, next];
+		});
+		const now = yield* Clock.currentTimeMillis;
+		const start = yield* Ref.get(intervalStartedAt);
+		if (len >= args.config.bufferedSteps) {
+			yield* flushInner;
+			return;
+		}
+		if (Option.isSome(start) && maxIntervalMs > 0 && now - start.value >= maxIntervalMs) {
+			yield* flushInner;
+			return;
+		}
+		if (Option.isNone(start) && maxIntervalMs > 0) yield* Ref.set(intervalStartedAt, Option.some(now));
+	});
+	const takeCompleted = () => Ref.modify(buffer, (current) => [current, Array.empty()]);
+	const plan = (planned) => Ref.update(plannedBuffer, (current) => [...current, planned]);
+	const takePlanned = () => Ref.modify(plannedBuffer, (current) => [[...current].sort((a, b) => a.sequence - b.sequence).map((entry) => entry.opcode), Array.empty()]);
+	return {
+		config: args.config,
+		runId: args.runId,
+		fnId: args.fnId,
+		qiId: args.qiId,
+		plan,
+		takePlanned,
+		record,
+		flush: flushInner,
+		takeCompleted,
+		markRuntimeExceeded: Ref.set(runtimeExceeded, true),
+		isRuntimeExceeded: Ref.get(runtimeExceeded)
+	};
+});
+//#endregion
+export { make };

package/dist/internal/checkpoint.d.ts

@@ -0,0 +1,2 @@
+import { CheckpointingOption } from "./checkpoint/Config.js";
+import { CheckpointApiError } from "./checkpoint/Error.js";

package/dist/internal/codec/EventPayload.d.ts

@@ -0,0 +1,6 @@
+import { EventDefinition } from "../../Event.js";
+import { Effect, Schema } from "effect";
+//#region src/internal/codec/EventPayload.d.ts
+type EventSchema = EventDefinition;
+//#endregion
+export { EventSchema };

package/dist/internal/codec/EventPayload.js

@@ -0,0 +1,60 @@
+import { FunctionInvoked } from "../../Events.js";
+import { eventSchemaFor, eventSchemas } from "../domain/FunctionDefinition.js";
+import { Array, Effect, Function, Option, Predicate, Schema } from "effect";
+//#region src/internal/codec/EventPayload.ts
+var EventDecodeError = class extends Schema.TaggedErrorClass()("EventDecodeError", {
+	eventName: Schema.String,
+	cause: Schema.Unknown
+}) {};
+const isFunctionInvoked = Schema.is(FunctionInvoked);
+const envelope = (event) => Schema.Struct({
+	name: Schema.tag(event.identifier),
+	data: event.schema,
+	id: Schema.optional(Schema.String),
+	ts: Schema.optional(Schema.Number),
+	v: Schema.optional(Schema.String)
+});
+const decodeEnvelope = Function.dual(2, (value, event) => {
+	const eventEnvelope = envelope(event);
+	return Schema.decodeUnknownEffect(Schema.toCodecJson(eventEnvelope))(value).pipe(Effect.mapError((cause) => EventDecodeError.make({
+		eventName: event.identifier,
+		cause
+	})));
+});
+const decodeMemoData = Function.dual(2, (value, event) => {
+	if (Predicate.isObject(value) && Predicate.hasProperty(value, "name")) return decodeEnvelope(event)(value);
+	return decodeEnvelope(event)({
+		name: event.identifier,
+		data: value
+	});
+});
+const decodeTriggerEvent = Function.dual(2, (event, fn) => Option.match(eventSchemaFor({
+	fn,
+	eventName: event.name
+}), {
+	onNone: () => Effect.fail(EventDecodeError.make({
+		eventName: event.name,
+		cause: "No matching event trigger schema"
+	})),
+	onSome: (eventSchema) => decodeEnvelope(eventSchema)(event)
+}));
+function decodeInvocation(args) {
+	const { fn, input } = args;
+	if (Predicate.isNotNullish(fn.options?.batchEvents)) return Effect.forEach(input.events, decodeTriggerEvent(fn));
+	if (isFunctionInvoked(input.event)) {
+		const { _inngest, ...payload } = input.event.data;
+		return Option.match(Array.head(eventSchemas(fn)), {
+			onNone: () => Effect.fail(EventDecodeError.make({
+				eventName: input.event.name,
+				cause: "No event trigger schema for invocation"
+			})),
+			onSome: (event) => decodeEnvelope(event)({
+				name: event.identifier,
+				data: payload
+			})
+		});
+	}
+	return decodeTriggerEvent(fn)(input.event);
+}
+//#endregion
+export { decodeInvocation, decodeMemoData };