effect-inngest 0.1.0

package/dist/internal/handler.js

@@ -0,0 +1,145 @@
+import { Headers, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import { InngestClient } from "../Client.js";
+import { Signature, SignatureError } from "./signature.js";
+import { execute } from "./driver.js";
+import * as HttpClient from "@effect/platform/HttpClient";
+import "@effect/platform/HttpServerRequest";
+import "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Predicate from "effect/Predicate";
+
+//#region src/internal/handler.ts
+/**
+* Internal handler implementation.
+* @internal
+*/
+var InvalidRequestError = class extends Schema.TaggedError()("InvalidRequestError", { message: Schema.String }) {};
+const SDK_VERSION = "2.0.0";
+const baseHeaders = () => ({
+	"Content-Type": "application/json",
+	[Headers.SDK]: `effect-inngest:v${SDK_VERSION}`,
+	[Headers.RequestVersion]: "1"
+});
+const buildServeUrl = (requestUrl, serveHost, servePath) => {
+	const url = new URL(requestUrl);
+	if (servePath) url.pathname = servePath;
+	if (serveHost) return new URL(url.pathname + url.search, serveHost);
+	return url;
+};
+const verifyAndParseRequestBody = (request) => Effect.gen(function* () {
+	const client = yield* InngestClient;
+	const sig = yield* Signature;
+	const config = client.config;
+	const isDev = client.mode === "dev";
+	const bodyText = yield* request.text.pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Failed to read request body: ${String(error)}` })));
+	yield* sig.verify({
+		body: new TextEncoder().encode(bodyText),
+		signatureHeader: request.headers[Headers.Signature.toLowerCase()],
+		signingKey: config.signingKey,
+		signingKeyFallback: config.signingKeyFallback,
+		isDev
+	});
+	return yield* Schema.decodeUnknown(Schema.parseJson(SDKRequestBody))(bodyText).pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Invalid request body: ${String(error)}` })));
+});
+const handleIntrospection = (group, _requestUrl) => Effect.gen(function* () {
+	const client = yield* InngestClient;
+	const config = client.config;
+	const body = {
+		function_count: group.functions.size,
+		has_event_key: config.eventKey !== void 0,
+		has_signing_key: config.signingKey !== void 0,
+		has_signing_key_fallback: config.signingKeyFallback !== void 0,
+		mode: client.mode === "dev" ? "dev" : "cloud",
+		schema_version: "2024-05-24",
+		authentication_succeeded: null
+	};
+	return {
+		status: 200,
+		headers: baseHeaders(),
+		body
+	};
+});
+const RegisterRequest = Schema.Struct({
+	url: Schema.String,
+	v: Schema.String,
+	deployType: Schema.Literal("ping"),
+	sdk: Schema.String,
+	appName: Schema.String,
+	framework: Schema.String,
+	functions: Schema.Array(Schema.Unknown)
+});
+const handleRegistration = (group, requestUrl) => Effect.gen(function* () {
+	const client = yield* InngestClient;
+	const httpClient = yield* HttpClient.HttpClient;
+	const config = client.config;
+	const url = buildServeUrl(requestUrl, config.serveHost, config.servePath);
+	const functions = Array.from(group.functions.values()).map((fn) => fn.toRegistration({
+		appId: config.id,
+		url: url.href
+	}));
+	const registerUrl = new URL("fn/register", client.apiBaseUrl).toString();
+	const response = yield* HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
+		...baseHeaders(),
+		Authorization: `Bearer ${config.signingKey ?? ""}`
+	}), HttpClientRequest.schemaBodyJson(RegisterRequest)({
+		url: url.href,
+		v: "0.1",
+		deployType: "ping",
+		sdk: `effect-inngest:v${SDK_VERSION}`,
+		appName: config.id,
+		framework: "effect",
+		functions
+	})).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(RegisterResponse)), Effect.scoped, Effect.catchAll((error) => Effect.succeed({ message: `Registration failed: ${Predicate.hasProperty(error, "message") ? error.message : "Unknown error"}` })));
+	return {
+		status: 200,
+		headers: baseHeaders(),
+		body: response
+	};
+});
+const handleExecution = (group, fnId, urlStepId, body, traceHeaders = {}) => Effect.gen(function* () {
+	const client = yield* InngestClient;
+	const context = yield* Effect.context();
+	const appId = client.config.id;
+	const prefix = `${appId}-`;
+	const fnTag = fnId.startsWith(prefix) ? fnId.slice(prefix.length) : fnId;
+	const fn = group.functions.get(fnTag);
+	const entry = fn ? context.unsafeMap.get(fn.key) : void 0;
+	if (!fn || !entry) return {
+		status: 404,
+		headers: {
+			...baseHeaders(),
+			[Headers.NoRetry]: "true"
+		},
+		body: { error: UserError.make({
+			name: "FunctionNotFoundError",
+			message: `Unknown function: ${fnId}`
+		}) }
+	};
+	const effectiveBody = urlStepId && urlStepId !== body.ctx.step_id ? SDKRequestBody.make({
+		event: body.event,
+		events: body.events,
+		steps: body.steps,
+		ctx: SDKRequestContext.make({
+			fn_id: body.ctx.fn_id,
+			run_id: body.ctx.run_id,
+			step_id: urlStepId,
+			attempt: body.ctx.attempt,
+			disable_immediate_execution: body.ctx.disable_immediate_execution,
+			use_api: body.ctx.use_api,
+			stack: body.ctx.stack
+		}),
+		use_api: body.use_api
+	}) : body;
+	const result = yield* Effect.provide(execute(fn, entry.handler, effectiveBody, appId, traceHeaders), entry.context);
+	return {
+		status: result.status,
+		headers: result.headers,
+		body: result.body
+	};
+});
+
+//#endregion
+export { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody };

package/dist/internal/helpers.js

@@ -0,0 +1,44 @@
+import * as Duration from "effect/Duration";
+
+//#region src/internal/helpers.ts
+/**
+* Internal helper utilities.
+* @internal
+*/
+const second = 1 * 1e3;
+const minute = second * 60;
+const hour = minute * 60;
+const day = hour * 24;
+const periods = [
+	["w", day * 7],
+	["d", day],
+	["h", hour],
+	["m", minute],
+	["s", second]
+];
+/**
+* Convert a Duration to an Inngest-compatible time string (e.g. `"1d"` or `"2h30m"`).
+*
+* Supports weeks, days, hours, minutes, and seconds. Years/months are converted
+* to their equivalent in weeks/days.
+*/
+const timeStr = (input) => {
+	let ms = Duration.toMillis(Duration.decode(input));
+	const [, result] = periods.reduce(([num, str], [suffix, period]) => {
+		const numPeriods = Math.floor(num / period);
+		if (numPeriods > 0) return [num % period, `${str}${numPeriods}${suffix}`];
+		return [num, str];
+	}, [ms, ""]);
+	return result || "0s";
+};
+/**
+* Format a timestamp as an ISO string for Inngest's sleepUntil.
+*/
+const formatTimestamp = (timestamp) => {
+	if (timestamp instanceof Date) return timestamp.toISOString();
+	if (typeof timestamp === "number") return new Date(timestamp).toISOString();
+	return timestamp;
+};
+
+//#endregion
+export { formatTimestamp, timeStr };

package/dist/internal/interrupts.d.ts

@@ -0,0 +1,2 @@
+import "./protocol.js";
+import "effect/Schema";

package/dist/internal/interrupts.js

@@ -0,0 +1,45 @@
+import { GeneratorOpcode, UserError, invokeFunction, sleep, stepError, stepPlanned, stepRun, waitForEvent } from "./protocol.js";
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+
+//#region src/internal/interrupts.ts
+/**
+* StepInterrupt schema and factory functions.
+* @internal
+*/
+/** @internal */
+var StepInterrupt = class extends Schema.TaggedClass()("StepInterrupt", {
+	opcode: GeneratorOpcode,
+	retryAfterMs: Schema.optional(Schema.Number)
+}) {};
+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
+});
+/** @internal */
+const sleepInterrupt = (opts) => StepInterrupt.make({ opcode: sleep(opts.info, opts.duration) });
+/** @internal */
+const waitForEventInterrupt = (opts) => StepInterrupt.make({ opcode: waitForEvent(opts.info, {
+	event: opts.event,
+	timeout: opts.timeout,
+	if: opts.if
+}) });
+/** @internal */
+const invokeInterrupt = (opts) => StepInterrupt.make({ opcode: invokeFunction(opts.info, {
+	function_id: opts.functionId,
+	payload: opts.payload,
+	timeout: opts.timeout
+}) });
+/** @internal */
+const plannedInterrupt = (opts) => StepInterrupt.make({ opcode: stepPlanned(opts.info) });
+/** @internal */
+const runInterrupt = (opts) => StepInterrupt.make({ opcode: stepRun(opts.info, opts.data) });
+/** @internal */
+const errorInterrupt = (opts) => StepInterrupt.make({
+	opcode: stepError(opts.info, toUserError(opts.error), opts.noRetry),
+	retryAfterMs: opts.retryAfterMs
+});
+
+//#endregion
+export { StepInterrupt, errorInterrupt, invokeInterrupt, plannedInterrupt, runInterrupt, sleepInterrupt, waitForEventInterrupt };

package/dist/internal/memo.js

@@ -0,0 +1,56 @@
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+
+//#region src/internal/memo.ts
+/**
+* Step memoization schemas for decoding cached step results.
+* @internal
+*/
+const hasKey = (key) => (u) => Predicate.isRecord(u) && Predicate.hasProperty(u, key);
+const MemoDataSchema = Schema.TaggedStruct("MemoData", { data: Schema.Unknown });
+const MemoErrorSchema = Schema.TaggedStruct("MemoError", { error: Schema.Unknown });
+const MemoInputSchema = Schema.TaggedStruct("MemoInput", { input: Schema.Unknown });
+const MemoTimeoutSchema = Schema.TaggedStruct("MemoTimeout", {});
+const MemoNoneSchema = Schema.TaggedStruct("MemoNone", {});
+const DataWire = Schema.Unknown.pipe(Schema.filter(hasKey("data")), Schema.transform(MemoDataSchema, {
+	decode: (v) => ({
+		_tag: "MemoData",
+		data: v.data
+	}),
+	encode: ({ data }) => ({ data })
+}));
+const ErrorWire = Schema.Unknown.pipe(Schema.filter(hasKey("error")), Schema.transform(MemoErrorSchema, {
+	decode: (v) => ({
+		_tag: "MemoError",
+		error: v.error
+	}),
+	encode: ({ error }) => ({ error })
+}));
+const InputWire = Schema.Unknown.pipe(Schema.filter(hasKey("input")), Schema.transform(MemoInputSchema, {
+	decode: (v) => ({
+		_tag: "MemoInput",
+		input: v.input
+	}),
+	encode: ({ input }) => ({ input })
+}));
+const TimeoutWire = Schema.transform(Schema.Null, MemoTimeoutSchema, {
+	decode: () => ({ _tag: "MemoTimeout" }),
+	encode: () => null
+});
+const NoneWire = Schema.transform(Schema.Undefined, MemoNoneSchema, {
+	decode: () => ({ _tag: "MemoNone" }),
+	encode: () => void 0
+});
+const MemoSchema = Schema.Union(ErrorWire, InputWire, DataWire, TimeoutWire, NoneWire);
+/**
+* Decode a step result into a Memo type.
+* Order matters: error > input > data (more specific properties first).
+*/
+const decodeMemo = (value) => {
+	const result = Schema.decodeUnknownOption(MemoSchema)(value);
+	if (result._tag === "Some") return result.value;
+	return MemoNoneSchema.make();
+};
+
+//#endregion
+export { decodeMemo };

package/dist/internal/protocol.d.ts

@@ -0,0 +1 @@
+import "effect/Schema";

package/dist/internal/protocol.js

@@ -0,0 +1,191 @@
+import { Predicate, Struct } from "effect";
+import * as Schema$1 from "effect/Schema";
+
+//#region src/internal/protocol.ts
+/**
+* Wire protocol schemas and opcode factories for Inngest communication.
+* @internal
+*/
+const stripTags = (value) => {
+	if (Predicate.isRecord(value)) {
+		const stripped = Struct.omit(value, "_tag");
+		return Object.fromEntries(Object.entries(stripped).map(([k, v]) => [k, stripTags(v)]));
+	}
+	if (Array.isArray(value)) return value.map(stripTags);
+	return value;
+};
+const WireUnknown = Schema$1.transform(Schema$1.Unknown, Schema$1.Unknown, {
+	strict: true,
+	decode: (value) => value,
+	encode: (value) => stripTags(value)
+});
+const Opcode = {
+	None: "None",
+	Step: "Step",
+	StepRun: "StepRun",
+	StepError: "StepError",
+	StepPlanned: "StepPlanned",
+	Sleep: "Sleep",
+	WaitForEvent: "WaitForEvent",
+	InvokeFunction: "InvokeFunction",
+	AIGateway: "AIGateway",
+	Gateway: "Gateway",
+	WaitForSignal: "WaitForSignal",
+	RunComplete: "RunComplete",
+	StepFailed: "StepFailed",
+	SyncRunComplete: "SyncRunComplete",
+	DiscoveryRequest: "DiscoveryRequest"
+};
+var UserError = class extends Schema$1.Class("UserError")({
+	name: Schema$1.String,
+	message: Schema$1.String,
+	stack: Schema$1.optional(Schema$1.String),
+	data: Schema$1.optional(Schema$1.Unknown),
+	noRetry: Schema$1.optional(Schema$1.Boolean),
+	cause: Schema$1.optional(Schema$1.Unknown)
+}) {};
+const StepResult = Schema$1.NullOr(Schema$1.Record({
+	key: Schema$1.String,
+	value: Schema$1.Unknown
+}).pipe(Schema$1.annotations({ identifier: "StepResultObject" })));
+var FunctionStack = class extends Schema$1.Class("FunctionStack")({
+	stack: Schema$1.Array(Schema$1.String),
+	current: Schema$1.Number
+}) {};
+var InngestEvent = class extends Schema$1.Class("InngestEvent")({
+	id: Schema$1.optional(Schema$1.String),
+	name: Schema$1.String,
+	data: Schema$1.optionalWith(Schema$1.Record({
+		key: Schema$1.String,
+		value: Schema$1.Unknown
+	}), {
+		default: () => ({}),
+		nullable: true
+	}),
+	ts: Schema$1.optional(Schema$1.Number),
+	user: Schema$1.optional(Schema$1.Record({
+		key: Schema$1.String,
+		value: Schema$1.Unknown
+	})),
+	v: Schema$1.optional(Schema$1.String)
+}) {};
+var SDKRequestContext = class extends Schema$1.Class("SDKRequestContext")({
+	fn_id: Schema$1.String,
+	run_id: Schema$1.String,
+	env: Schema$1.optionalWith(Schema$1.String, { default: () => "dev" }),
+	step_id: Schema$1.optionalWith(Schema$1.String, { default: () => "step" }),
+	attempt: Schema$1.optionalWith(Schema$1.Number, { default: () => 0 }),
+	max_attempts: Schema$1.optionalWith(Schema$1.Number, { default: () => 4 }),
+	stack: Schema$1.optionalWith(FunctionStack, { default: () => FunctionStack.make({
+		stack: [],
+		current: 0
+	}) }),
+	qi_id: Schema$1.optionalWith(Schema$1.String, { default: () => "" }),
+	disable_immediate_execution: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false }),
+	use_api: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false })
+}) {};
+var SDKRequestBody = class extends Schema$1.Class("SDKRequestBody")({
+	event: InngestEvent,
+	events: Schema$1.Array(InngestEvent),
+	steps: Schema$1.optionalWith(Schema$1.Record({
+		key: Schema$1.String,
+		value: StepResult
+	}), { default: () => ({}) }),
+	ctx: SDKRequestContext,
+	version: Schema$1.optionalWith(Schema$1.Number, { default: () => 1 }),
+	use_api: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false })
+}) {};
+const Headers = {
+	SDK: "X-Inngest-SDK",
+	Signature: "X-Inngest-Signature",
+	RequestVersion: "x-inngest-req-version",
+	NoRetry: "X-Inngest-No-Retry",
+	RetryAfter: "Retry-After",
+	ServerKind: "X-Inngest-Server-Kind",
+	ExpectedServerKind: "X-Inngest-Expected-Server-Kind",
+	RunID: "X-Run-ID",
+	Framework: "X-Inngest-Framework",
+	Platform: "X-Inngest-Platform",
+	Env: "X-Inngest-Env"
+};
+var GeneratorOpcode = class extends Schema$1.Class("GeneratorOpcode")({
+	op: Schema$1.Literal(Opcode.None, Opcode.Step, Opcode.StepRun, Opcode.StepError, Opcode.StepPlanned, Opcode.Sleep, Opcode.WaitForEvent, Opcode.InvokeFunction, Opcode.AIGateway, Opcode.Gateway, Opcode.WaitForSignal, Opcode.RunComplete, Opcode.StepFailed, Opcode.SyncRunComplete, Opcode.DiscoveryRequest),
+	id: Schema$1.String,
+	name: Schema$1.String,
+	mode: Schema$1.optional(Schema$1.Literal("sync", "async")),
+	opts: Schema$1.optional(WireUnknown),
+	data: Schema$1.optional(WireUnknown),
+	error: Schema$1.optional(UserError),
+	displayName: Schema$1.optional(Schema$1.String),
+	userland: Schema$1.optional(Schema$1.Struct({ id: Schema$1.String }))
+}) {};
+const mkOpcode = (info, op, extra) => GeneratorOpcode.make({
+	op,
+	id: info.hash,
+	name: info.id,
+	displayName: info.name,
+	...extra
+});
+const stepPlanned = (info) => mkOpcode(info, Opcode.StepPlanned);
+const stepRun = (info, data) => mkOpcode(info, Opcode.StepRun, { data });
+const stepError = (info, error, noRetry) => {
+	const errorWithNoRetry = noRetry !== void 0 ? UserError.make({
+		name: error.name,
+		message: error.message,
+		stack: error.stack,
+		noRetry
+	}) : error;
+	return mkOpcode(info, Opcode.StepError, { error: errorWithNoRetry });
+};
+const sleep = (info, duration) => GeneratorOpcode.make({
+	op: Opcode.Sleep,
+	id: info.hash,
+	name: duration,
+	displayName: info.name,
+	mode: "async"
+});
+const waitForEvent = (info, opts) => mkOpcode(info, Opcode.WaitForEvent, {
+	mode: "async",
+	opts
+});
+const invokeFunction = (info, opts) => mkOpcode(info, Opcode.InvokeFunction, {
+	mode: "async",
+	opts,
+	userland: { id: info.id }
+});
+const IntrospectionBase = Schema$1.Struct({
+	function_count: Schema$1.Number,
+	has_event_key: Schema$1.Boolean,
+	has_signing_key: Schema$1.Boolean,
+	has_signing_key_fallback: Schema$1.Boolean,
+	mode: Schema$1.Literal("cloud", "dev"),
+	schema_version: Schema$1.Literal("2024-05-24"),
+	extra: Schema$1.optional(Schema$1.Record({
+		key: Schema$1.String,
+		value: Schema$1.Unknown
+	}))
+});
+const IntrospectionUnauthenticated = Schema$1.extend(IntrospectionBase, Schema$1.Struct({
+	authentication_succeeded: Schema$1.Union(Schema$1.Literal(false), Schema$1.Null),
+	functions: Schema$1.optionalWith(Schema$1.Array(Schema$1.Unknown), { exact: true })
+}));
+const IntrospectionAuthenticated = Schema$1.extend(IntrospectionBase, Schema$1.Struct({
+	authentication_succeeded: Schema$1.Literal(true),
+	api_origin: Schema$1.String,
+	app_id: Schema$1.String,
+	env: Schema$1.NullOr(Schema$1.String),
+	event_api_origin: Schema$1.String,
+	event_key_hash: Schema$1.NullOr(Schema$1.String),
+	framework: Schema$1.String,
+	sdk_language: Schema$1.String,
+	sdk_version: Schema$1.String,
+	serve_origin: Schema$1.NullOr(Schema$1.String),
+	serve_path: Schema$1.NullOr(Schema$1.String),
+	signing_key_fallback_hash: Schema$1.NullOr(Schema$1.String),
+	signing_key_hash: Schema$1.NullOr(Schema$1.String)
+}));
+const IntrospectionResponse = Schema$1.Union(IntrospectionAuthenticated, IntrospectionUnauthenticated);
+const RegisterResponse = Schema$1.Struct({ message: Schema$1.optional(Schema$1.String) });
+
+//#endregion
+export { GeneratorOpcode, Headers, IntrospectionResponse, Opcode, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError, invokeFunction, sleep, stepError, stepPlanned, stepRun, waitForEvent };

package/dist/internal/signature.d.ts

@@ -0,0 +1,18 @@
+import "effect/Context";
+import "effect/Effect";
+import "effect/Layer";
+import * as Schema from "effect/Schema";
+
+//#region src/internal/signature.d.ts
+declare const SignatureError_base: Schema.TaggedErrorClass<SignatureError, "SignatureError", {
+  readonly _tag: Schema.tag<"SignatureError">;
+} & {
+  reason: Schema.Literal<["missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"]>;
+  message: typeof Schema.String;
+}>;
+/**
+ * @internal
+ */
+declare class SignatureError extends SignatureError_base {}
+//#endregion
+export { SignatureError };

package/dist/internal/signature.js

@@ -0,0 +1,97 @@
+import { Headers } from "./protocol.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Crypto from "node:crypto";
+import * as DateTime from "effect/DateTime";
+
+//#region src/internal/signature.ts
+/**
+* Signature verification service for Inngest requests.
+* @internal
+*/
+/**
+* @internal
+*/
+var SignatureError = class extends Schema.TaggedError()("SignatureError", {
+	reason: Schema.Literal("missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"),
+	message: Schema.String
+}) {};
+/**
+* @internal
+*/
+var Signature = class extends Context.Tag("effect-inngest/Signature")() {};
+const TimestampSeconds = Schema.NumberFromString.pipe(Schema.int(), Schema.positive());
+const SignatureHex = Schema.String.pipe(Schema.pattern(/^[a-fA-F0-9]{64}$/), Schema.transform(Schema.String, {
+	decode: (s) => s.toLowerCase(),
+	encode: (s) => s
+}));
+const SignatureParams = Schema.Struct({
+	t: TimestampSeconds,
+	s: SignatureHex
+});
+const SIGNATURE_VALIDITY_WINDOW_MS = 300 * 1e3;
+const parseSignatureHeader = (header) => {
+	const params = new URLSearchParams(header);
+	const raw = {
+		t: params.get("t") ?? "",
+		s: params.get("s") ?? ""
+	};
+	return Schema.decodeUnknown(SignatureParams)(raw).pipe(Effect.mapError(() => new SignatureError({
+		reason: "invalid_format",
+		message: `Invalid signature format: expected t=<int>&s=<64-hex>, got: ${header}`
+	})));
+};
+const extractKeyBytes = (signingKey) => {
+	const keyWithoutPrefix = signingKey.replace(/^signkey-\w+-/, "");
+	return Buffer.from(keyWithoutPrefix, "hex");
+};
+const computeSignature = (keyBytes, body, timestamp) => Crypto.createHmac("sha256", keyBytes).update(body).update(timestamp).digest("hex");
+const timingSafeEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	try {
+		return Crypto.timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+	} catch {
+		return false;
+	}
+};
+const checkSignature = (signature, body, timestamp, signingKey) => {
+	return timingSafeEqual(signature, computeSignature(extractKeyBytes(signingKey), body, timestamp));
+};
+/**
+* @internal
+*/
+const SignatureLive = Layer.effect(Signature, Effect.succeed({
+	verify: ({ body, signatureHeader, signingKey, signingKeyFallback, isDev }) => Effect.gen(function* () {
+		if (isDev) return true;
+		if (!signingKey) return yield* new SignatureError({
+			reason: "missing_signing_key",
+			message: "No signing key configured for production mode"
+		});
+		if (!signatureHeader) return yield* new SignatureError({
+			reason: "missing_header",
+			message: `Missing ${Headers.Signature} header`
+		});
+		const { t: timestampSeconds, s: signature } = yield* parseSignatureHeader(signatureHeader);
+		const timestampMs = timestampSeconds * 1e3;
+		const now = yield* DateTime.now;
+		if (Math.abs(now.epochMillis - timestampMs) > SIGNATURE_VALIDITY_WINDOW_MS) return yield* new SignatureError({
+			reason: "expired",
+			message: `Signature expired: timestamp ${timestampSeconds} is outside the validity window`
+		});
+		const timestamp = String(timestampSeconds);
+		if ([signingKey, signingKeyFallback].filter(Boolean).some((key) => checkSignature(signature, body, timestamp, key))) return true;
+		return yield* new SignatureError({
+			reason: "invalid_signature",
+			message: "Invalid signature"
+		});
+	}),
+	sign: (body, signingKey) => DateTime.now.pipe(Effect.map((now) => {
+		const ts = Math.floor(now.epochMillis / 1e3);
+		return `t=${ts}&s=${computeSignature(extractKeyBytes(signingKey), body, String(ts))}`;
+	}))
+}));
+
+//#endregion
+export { Signature, SignatureError, SignatureLive };

package/dist/internal/step.d.ts

@@ -0,0 +1,59 @@
+import { InngestFunction } from "../Function.js";
+import "./protocol.js";
+import { SendEventError, StepError } from "./errors.js";
+import "./interrupts.js";
+import * as Duration from "effect/Duration";
+import "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import "effect/HashMap";
+import "effect/Ref";
+
+//#region src/internal/step.d.ts
+interface StepOptions {
+  readonly id: string;
+  readonly name?: string;
+}
+type StepOptionsOrId = string | StepOptions;
+interface WaitForEventOptions {
+  readonly timeout: Duration.DurationInput;
+  readonly if?: string;
+}
+interface InvokeOptionsBase<F extends InngestFunction.Any> {
+  readonly function: F;
+  readonly user?: Record<string, unknown>;
+  readonly v?: string;
+  readonly timeout?: Duration.DurationInput;
+}
+type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventType<F>] extends [never] ? InvokeOptionsBase<F> : InvokeOptionsBase<F> & {
+  readonly data: InngestFunction.EventType<F>;
+};
+type EventSchema = Schema.Schema.Any & {
+  readonly _tag: string;
+};
+type TaggedEvent = {
+  readonly _tag: string;
+};
+interface StepTools {
+  readonly run: <A, Err, R>(id: StepOptionsOrId, effect: Effect.Effect<A, Err, R>) => Effect.Effect<A, StepError | Err, R>;
+  readonly sleep: (id: StepOptionsOrId, duration: Duration.DurationInput) => Effect.Effect<void>;
+  readonly sleepUntil: (id: StepOptionsOrId, timestamp: Date | number | string) => Effect.Effect<void>;
+  readonly waitForEvent: <E extends EventSchema>(id: StepOptionsOrId, event: E, options: WaitForEventOptions) => Effect.Effect<Option.Option<Schema.Schema.Type<E>>>;
+  readonly invoke: <F extends InngestFunction.Any>(id: StepOptionsOrId, options: InvokeOptions<F>) => Effect.Effect<InngestFunction.Success<F>, StepError>;
+  readonly sendEvent: (id: StepOptionsOrId, payload: TaggedEvent | ReadonlyArray<TaggedEvent>) => Effect.Effect<{
+    readonly ids: ReadonlyArray<string>;
+  }, SendEventError>;
+}
+interface RunContext {
+  readonly id: string;
+  readonly attempt: number;
+  readonly maxAttempts: number;
+}
+interface HandlerContext<F extends InngestFunction.Any> {
+  readonly event: InngestFunction.EventType<F>;
+  readonly step: StepTools;
+  readonly run: RunContext;
+}
+//#endregion
+export { HandlerContext };