effect-inngest 0.1.0

package/dist/Group.js

@@ -0,0 +1,164 @@
+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";
+
+//#region src/Group.ts
+/**
+* @since 0.1.0
+*/
+var Group_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	make: () => make,
+	toHttpApp: () => toHttpApp,
+	toWebHandler: () => toWebHandler
+});
+/**
+* @since 0.1.0
+* @category type ids
+*/
+const TypeId = Symbol.for("effect-inngest/Group");
+const Proto = {
+	[TypeId]: TypeId,
+	toLayer(handlers) {
+		const functions = this.functions;
+		return Layer.effectContext(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, {
+					handler,
+					context
+				});
+			}
+			return Context.unsafeMake(contextMap);
+		}));
+	},
+	toLayerHandler(tag, handler) {
+		const fn = this.functions.get(tag);
+		return Layer.effectContext(Effect.gen(function* () {
+			const context = yield* Effect.context();
+			const contextMap = /* @__PURE__ */ new Map();
+			contextMap.set(fn.key, {
+				handler,
+				context
+			});
+			return Context.unsafeMake(contextMap);
+		}));
+	}
+};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const make = (...fns) => {
+	const functions = new Map(fns.map((fn) => [fn._tag, fn]));
+	const group = Object.create(Proto);
+	group.functions = functions;
+	return group;
+};
+/**
+* Build an HttpApp from an InngestGroup.
+*
+* @since 0.1.0
+* @category http
+* @example
+* ```ts
+* import { Effect, Layer } from "effect"
+* import { HttpServer } from "@effect/platform"
+* import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
+* import { InngestGroup, InngestClient } from "effect-inngest"
+*
+* InngestGroup.toHttpApp(MyGroup).pipe(
+*   Effect.flatMap((app) => HttpServer.serve(app)),
+*   Effect.provide(InngestClient.layer({ id: "my-app" })),
+*   Effect.provide(NodeHttpServer.layer({ port: 3000 })),
+*   NodeRuntime.runMain,
+* )
+* ```
+*/
+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)));
+/**
+* Create a standalone web handler from an InngestGroup.
+*
+* @since 0.1.0
+* @category http
+* @example
+* ```ts
+* import { InngestGroup, InngestClient } from "effect-inngest"
+* import { HttpClient } from "@effect/platform"
+* import { FetchHttpClient } from "@effect/platform"
+*
+* const { handler, dispose } = InngestGroup.toWebHandler(MyGroup, {
+*   layer: InngestClient.layer({ id: "my-app" }).pipe(
+*     Layer.provide(FetchHttpClient.layer),
+*   ),
+* })
+*
+* // Use with any web framework
+* Bun.serve({ fetch: handler, port: 3000 })
+*
+* // Call dispose() on shutdown
+* process.on("SIGTERM", dispose)
+* ```
+*/
+const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope), { memoMap: options.memoMap });
+
+//#endregion
+export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/dist/HttpApi.d.ts

@@ -0,0 +1,75 @@
+import { InngestClient } from "./Client.js";
+import { InngestGroup } from "./Group.js";
+import { SignatureError } from "./internal/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";
+
+//#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 class FunctionNotFoundError extends FunctionNotFoundError_base {}
+/**
+ * @since 0.1.0
+ * @category api
+ */
+declare const InngestApiGroup: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpoint.HttpApiEndpoint<"introspect", "GET", never, never, never, never, ({
+  readonly mode: "cloud" | "dev";
+  readonly function_count: number;
+  readonly has_event_key: boolean;
+  readonly has_signing_key: boolean;
+  readonly has_signing_key_fallback: boolean;
+  readonly schema_version: "2024-05-24";
+  readonly extra?: {
+    readonly [x: string]: unknown;
+  } | undefined;
+} & {
+  readonly env: string | null;
+  readonly authentication_succeeded: true;
+  readonly api_origin: string;
+  readonly app_id: string;
+  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 mode: "cloud" | "dev";
+  readonly function_count: number;
+  readonly has_event_key: boolean;
+  readonly has_signing_key: boolean;
+  readonly has_signing_key_fallback: boolean;
+  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>;
+/**
+ * @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>;
+//#endregion
+export { HttpApi_d_exports, InngestApiGroup, layerGroup };

package/dist/HttpApi.js

@@ -0,0 +1,47 @@
+import { __exportAll } from "./_virtual/rolldown_runtime.js";
+import { IntrospectionResponse, RegisterResponse } from "./internal/protocol.js";
+import { SignatureError, SignatureLive } from "./internal/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";
+
+//#region src/HttpApi.ts
+var HttpApi_exports = /* @__PURE__ */ __exportAll({
+	InngestApiGroup: () => InngestApiGroup,
+	layerGroup: () => layerGroup
+});
+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);
+/**
+* @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 });
+/**
+* @since 0.1.0
+* @category layers
+*/
+const layerGroup = (api, group) => {
+	const toUrl = (req) => Option.match(HttpServerRequest.toURL(req), {
+		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))));
+};
+
+//#endregion
+export { HttpApi_exports, InngestApiGroup, layerGroup };

package/dist/_virtual/rolldown_runtime.js

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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Client_d_exports } from "./Client.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 };

package/dist/index.js

@@ -0,0 +1,8 @@
+import { Function_exports } from "./Function.js";
+import { Client_exports } from "./Client.js";
+import { NonRetriableError, RetryAfterError } from "./internal/errors.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 };

package/dist/internal/constants.js

@@ -0,0 +1,15 @@
+//#region src/internal/constants.ts
+const OtelAttributes = {
+	RunId: "inngest.run_id",
+	FunctionId: "inngest.function_id",
+	AppId: "inngest.app_id",
+	Attempt: "inngest.attempt",
+	StepId: "inngest.step.id",
+	StepType: "inngest.step.type",
+	ExceptionType: "exception.type",
+	ExceptionMessage: "exception.message",
+	ExceptionStacktrace: "exception.stacktrace"
+};
+
+//#endregion
+export { OtelAttributes };

package/dist/internal/driver.d.ts

@@ -0,0 +1,5 @@
+import "../Client.js";
+import "../Function.js";
+import "./protocol.js";
+import "./step.js";
+import { Effect, Schema } from "effect";

package/dist/internal/driver.js

@@ -0,0 +1,117 @@
+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";
+
+//#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 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
+	}
+}));
+
+//#endregion
+export { execute };

package/dist/internal/errors.d.ts

@@ -0,0 +1,56 @@
+import * as Schema from "effect/Schema";
+
+//#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 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 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 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 class RetryAfterError extends RetryAfterError_base {}
+//#endregion
+export { NonRetriableError, RetryAfterError, SendEventError, StepError };

package/dist/internal/errors.js

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

package/dist/internal/handler.d.ts

@@ -0,0 +1,20 @@
+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";
+
+//#region src/internal/handler.d.ts
+declare const InvalidRequestError_base: Schema.TaggedErrorClass<InvalidRequestError, "InvalidRequestError", {
+  readonly _tag: Schema.tag<"InvalidRequestError">;
+} & {
+  message: typeof Schema.String;
+}>;
+declare class InvalidRequestError extends InvalidRequestError_base {}
+//#endregion
+export { InvalidRequestError };