effect-inngest 0.1.2 → 0.2.0-beta.0

package/dist/internal/helpers.js

@@ -1,11 +1,12 @@
 import * as Duration from "effect/Duration";
-
+import * as DateTime from "effect/DateTime";
 //#region src/internal/helpers.ts
 /**
 * Internal helper utilities.
 * @internal
 */
-const second = 1 * 1e3;
+const millisecond = 1;
+const second = millisecond * 1e3;
 const minute = second * 60;
 const hour = minute * 60;
 const day = hour * 24;
@@ -14,7 +15,8 @@ const periods = [
 	["d", day],
 	["h", hour],
 	["m", minute],
-	["s", second]
+	["s", second],
+	["ms", millisecond]
 ];
 /**
 * Convert a Duration to an Inngest-compatible time string (e.g. `"1d"` or `"2h30m"`).
@@ -23,7 +25,7 @@ const periods = [
 * to their equivalent in weeks/days.
 */
 const timeStr = (input) => {
-	let ms = Duration.toMillis(Duration.decode(input));
+	let ms = Duration.toMillis(Duration.fromInputUnsafe(input));
 	const [, result] = periods.reduce(([num, str], [suffix, period]) => {
 		const numPeriods = Math.floor(num / period);
 		if (numPeriods > 0) return [num % period, `${str}${numPeriods}${suffix}`];
@@ -33,12 +35,13 @@ const timeStr = (input) => {
 };
 /**
 * Format a timestamp as an ISO string for Inngest's sleepUntil.
+*
+* String inputs are passed through unchanged (assumed ISO-formatted), matching
+* the prior contract. Date/number inputs are normalized via DateTime.
 */
 const formatTimestamp = (timestamp) => {
-	if (timestamp instanceof Date) return timestamp.toISOString();
-	if (typeof timestamp === "number") return new Date(timestamp).toISOString();
-	return timestamp;
+	if (typeof timestamp === "string") return timestamp;
+	return DateTime.formatIso(DateTime.makeUnsafe(timestamp));
 };
-
 //#endregion
-export { formatTimestamp, timeStr };
+export { formatTimestamp, timeStr };

package/dist/internal/interrupts.d.ts

@@ -1,2 +1 @@
-import "./protocol.js";
-import "effect/Schema";
+export { };

package/dist/internal/interrupts.js

@@ -1,7 +1,6 @@
 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.
@@ -40,6 +39,5 @@ 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 };
+export { StepInterrupt, errorInterrupt, invokeInterrupt, plannedInterrupt, runInterrupt, sleepInterrupt, waitForEventInterrupt };

package/dist/internal/memo.js

@@ -1,56 +1,58 @@
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
-
+import * as SchemaTransformation from "effect/SchemaTransformation";
 //#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 hasKey = (key) => (u) => Predicate.isObject(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, {
+const DataWire = Schema.Unknown.pipe(Schema.check(Schema.makeFilter(hasKey("data"))), Schema.decodeTo(MemoDataSchema, SchemaTransformation.transform({
 	decode: (v) => ({
 		_tag: "MemoData",
 		data: v.data
 	}),
 	encode: ({ data }) => ({ data })
-}));
-const ErrorWire = Schema.Unknown.pipe(Schema.filter(hasKey("error")), Schema.transform(MemoErrorSchema, {
+})));
+const ErrorWire = Schema.Unknown.pipe(Schema.check(Schema.makeFilter(hasKey("error"))), Schema.decodeTo(MemoErrorSchema, SchemaTransformation.transform({
 	decode: (v) => ({
 		_tag: "MemoError",
 		error: v.error
 	}),
 	encode: ({ error }) => ({ error })
-}));
-const InputWire = Schema.Unknown.pipe(Schema.filter(hasKey("input")), Schema.transform(MemoInputSchema, {
+})));
+const InputWire = Schema.Unknown.pipe(Schema.check(Schema.makeFilter(hasKey("input"))), Schema.decodeTo(MemoInputSchema, SchemaTransformation.transform({
 	decode: (v) => ({
 		_tag: "MemoInput",
 		input: v.input
 	}),
 	encode: ({ input }) => ({ input })
-}));
-const TimeoutWire = Schema.transform(Schema.Null, MemoTimeoutSchema, {
+})));
+const TimeoutWire = Schema.Null.pipe(Schema.decodeTo(MemoTimeoutSchema, SchemaTransformation.transform({
 	decode: () => ({ _tag: "MemoTimeout" }),
 	encode: () => null
-});
-const NoneWire = Schema.transform(Schema.Undefined, MemoNoneSchema, {
+})));
+const NoneWire = Schema.Undefined.pipe(Schema.decodeTo(MemoNoneSchema, SchemaTransformation.transform({
 	decode: () => ({ _tag: "MemoNone" }),
 	encode: () => void 0
-});
-const MemoSchema = Schema.Union(ErrorWire, InputWire, DataWire, TimeoutWire, NoneWire);
+})));
+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();
-};
-
+const decodeMemo = (value) => Option.getOrElse(Schema.decodeUnknownOption(MemoSchema)(value), () => MemoNoneSchema.make({}));
 //#endregion
-export { decodeMemo };
+export { decodeMemo };

package/dist/internal/protocol.d.ts

@@ -1 +1,28 @@
-import "effect/Schema";
+import * as Schema from "effect/Schema";
+
+//#region src/internal/protocol.d.ts
+declare const UserError_base: Schema.Class<UserError, Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly stack: Schema.optional<Schema.String>;
+  readonly data: Schema.optional<Schema.Unknown>;
+  readonly noRetry: Schema.optional<Schema.Boolean>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, {}>;
+declare class UserError extends UserError_base {}
+declare const GeneratorOpcode_base: Schema.Class<GeneratorOpcode, Schema.Struct<{
+  readonly op: Schema.Literals<readonly ["None", "Step", "StepRun", "StepError", "StepPlanned", "Sleep", "WaitForEvent", "InvokeFunction", "AIGateway", "Gateway", "WaitForSignal", "RunComplete", "StepFailed", "SyncRunComplete", "DiscoveryRequest"]>;
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+  readonly mode: Schema.optional<Schema.Literals<readonly ["sync", "async"]>>;
+  readonly opts: Schema.optional<Schema.decodeTo<Schema.Unknown, Schema.Unknown, never, never>>;
+  readonly data: Schema.optional<Schema.decodeTo<Schema.Unknown, Schema.Unknown, never, never>>;
+  readonly error: Schema.optional<typeof UserError>;
+  readonly displayName: Schema.optional<Schema.String>;
+  readonly userland: Schema.optional<Schema.Struct<{
+    readonly id: Schema.String;
+  }>>;
+}>, {}>;
+declare class GeneratorOpcode extends GeneratorOpcode_base {}
+//#endregion
+export { GeneratorOpcode };

package/dist/internal/protocol.js

@@ -1,20 +1,18 @@
-import { Predicate, Struct } from "effect";
+import { Effect, Predicate, SchemaTransformation, 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 stripTopLevelTag = (value) => {
-	if (Predicate.isRecord(value)) return Struct.omit(value, "_tag");
+	if (Predicate.isObject(value)) return Struct.omit(value, ["_tag"]);
 	return value;
 };
-const WireUnknown = Schema$1.transform(Schema$1.Unknown, Schema$1.Unknown, {
-	strict: true,
+const WireUnknown = Schema$1.Unknown.pipe(Schema$1.decodeTo(Schema$1.Unknown, SchemaTransformation.transform({
 	decode: (value) => value,
 	encode: (value) => stripTopLevelTag(value)
-});
+})));
 const Opcode = {
 	None: "None",
 	Step: "Step",
@@ -40,10 +38,7 @@ var UserError = class extends Schema$1.Class("UserError")({
 	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" })));
+const StepResult = Schema$1.NullOr(Schema$1.Record(Schema$1.String, Schema$1.Unknown).pipe(Schema$1.annotate({ identifier: "StepResultObject" })));
 var FunctionStack = class extends Schema$1.Class("FunctionStack")({
 	stack: Schema$1.Array(Schema$1.String),
 	current: Schema$1.Number
@@ -51,45 +46,33 @@ var FunctionStack = class extends Schema$1.Class("FunctionStack")({
 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
-	}),
+	data: Schema$1.NullOr(Schema$1.Record(Schema$1.String, Schema$1.Unknown)).pipe(Schema$1.withDecodingDefaultType(Effect.succeed({}))),
 	ts: Schema$1.optional(Schema$1.Number),
-	user: Schema$1.optional(Schema$1.Record({
-		key: Schema$1.String,
-		value: Schema$1.Unknown
-	})),
+	user: Schema$1.optional(Schema$1.Record(Schema$1.String, 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({
+	env: Schema$1.String.pipe(Schema$1.withDecodingDefault(Effect.succeed("dev"))),
+	step_id: Schema$1.String.pipe(Schema$1.withDecodingDefault(Effect.succeed("step"))),
+	attempt: Schema$1.Number.pipe(Schema$1.withDecodingDefault(Effect.succeed(0))),
+	max_attempts: Schema$1.Number.pipe(Schema$1.withDecodingDefault(Effect.succeed(4))),
+	stack: FunctionStack.pipe(Schema$1.withDecodingDefaultType(Effect.succeed(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 })
+	})))),
+	qi_id: Schema$1.String.pipe(Schema$1.withDecodingDefault(Effect.succeed(""))),
+	disable_immediate_execution: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
+	use_api: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(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: () => ({}) }),
+	steps: Schema$1.Record(Schema$1.String, StepResult).pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 	ctx: SDKRequestContext,
-	version: Schema$1.optionalWith(Schema$1.Number, { default: () => 1 }),
-	use_api: Schema$1.optionalWith(Schema$1.Boolean, { default: () => false })
+	version: Schema$1.Number.pipe(Schema$1.withDecodingDefault(Effect.succeed(1))),
+	use_api: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false)))
 }) {};
 const Headers = {
 	SDK: "X-Inngest-SDK",
@@ -105,10 +88,26 @@ const Headers = {
 	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),
+	op: Schema$1.Literals([
+		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")),
+	mode: Schema$1.optional(Schema$1.Literals(["sync", "async"])),
 	opts: Schema$1.optional(WireUnknown),
 	data: Schema$1.optional(WireUnknown),
 	error: Schema$1.optional(UserError),
@@ -138,7 +137,8 @@ const sleep = (info, duration) => GeneratorOpcode.make({
 	id: info.hash,
 	name: duration,
 	displayName: info.name,
-	mode: "async"
+	mode: "async",
+	opts: { duration }
 });
 const waitForEvent = (info, opts) => mkOpcode(info, Opcode.WaitForEvent, {
 	mode: "async",
@@ -149,23 +149,41 @@ const invokeFunction = (info, opts) => mkOpcode(info, Opcode.InvokeFunction, {
 	opts,
 	userland: { id: info.id }
 });
+/**
+* Terminal opcode emitted by the SDK in checkpoint mode when the function
+* completes successfully. The executor uses this to correlate run completion
+* (spec §10.4.1).
+*/
+const runComplete = (data) => GeneratorOpcode.make({
+	op: Opcode.RunComplete,
+	id: "step",
+	name: "step",
+	data
+});
+/**
+* Yield opcode emitted by the SDK in checkpoint mode when `maxRuntime` is
+* exceeded. Tells the executor to schedule a new Call Request to continue
+* execution (spec §10.4.1).
+*/
+const discoveryRequest = () => GeneratorOpcode.make({
+	op: Opcode.DiscoveryRequest,
+	id: "step",
+	name: "step"
+});
 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"),
+	mode: Schema$1.Literals(["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
-	}))
+	extra: Schema$1.optional(Schema$1.Record(Schema$1.String, 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 IntrospectionUnauthenticated = IntrospectionBase.pipe(Schema$1.fieldsAssign({
+	authentication_succeeded: Schema$1.Union([Schema$1.Literal(false), Schema$1.Null]),
+	functions: Schema$1.optionalKey(Schema$1.Array(Schema$1.Unknown))
 }));
-const IntrospectionAuthenticated = Schema$1.extend(IntrospectionBase, Schema$1.Struct({
+const IntrospectionAuthenticated = IntrospectionBase.pipe(Schema$1.fieldsAssign({
 	authentication_succeeded: Schema$1.Literal(true),
 	api_origin: Schema$1.String,
 	app_id: Schema$1.String,
@@ -180,8 +198,22 @@ const IntrospectionAuthenticated = Schema$1.extend(IntrospectionBase, Schema$1.S
 	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) });
-
+const IntrospectionResponse = Schema$1.Union([IntrospectionAuthenticated, IntrospectionUnauthenticated]);
+/**
+* SDK → executor response shape for PUT sync requests per spec §4.3.1.
+*/
+const RegisterResponse = Schema$1.Struct({
+	message: Schema$1.String,
+	modified: Schema$1.Boolean
+});
+/**
+* Executor → SDK response shape from `POST /fn/register` per spec §4.3.4.
+* On success the body has `{ ok: true, modified?: boolean }`; on failure
+* the body may carry an `error` string.
+*/
+const RegisterServerResponse = Schema$1.Union([Schema$1.Struct({
+	ok: Schema$1.Literal(true),
+	modified: Schema$1.optional(Schema$1.Boolean)
+}), Schema$1.Struct({ error: Schema$1.optional(Schema$1.String) })]);
 //#endregion
-export { GeneratorOpcode, Headers, IntrospectionResponse, Opcode, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError, invokeFunction, sleep, stepError, stepPlanned, stepRun, waitForEvent };
+export { GeneratorOpcode, Headers, IntrospectionResponse, Opcode, RegisterResponse, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError, discoveryRequest, invokeFunction, runComplete, sleep, stepError, stepPlanned, stepRun, waitForEvent };

package/dist/internal/signature.d.ts

@@ -1,15 +1,11 @@
-import "effect/Context";
-import "effect/Effect";
-import "effect/Layer";
 import * as Schema from "effect/Schema";
+import * as _$effect_Cause0 from "effect/Cause";
 
 //#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;
-}>;
+declare const SignatureError_base: Schema.Class<SignatureError, Schema.TaggedStruct<"SignatureError", {
+  readonly reason: Schema.Literals<readonly ["missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"]>;
+  readonly message: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
 /**
  * @internal
  */

package/dist/internal/signature.js

@@ -1,11 +1,11 @@
 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";
-
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Crypto from "node:crypto";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 //#region src/internal/signature.ts
 /**
 * Signature verification service for Inngest requests.
@@ -14,19 +14,25 @@ import * as DateTime from "effect/DateTime";
 /**
 * @internal
 */
-var SignatureError = class extends Schema.TaggedError()("SignatureError", {
-	reason: Schema.Literal("missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"),
+var SignatureError = class extends Schema.TaggedErrorClass()("SignatureError", {
+	reason: Schema.Literals([
+		"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, {
+var Signature = class extends Context.Service()("effect-inngest/Signature") {};
+const TimestampSeconds = Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThan(0)));
+const SignatureHex = Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-fA-F0-9]{64}$/)), Schema.decodeTo(Schema.String, SchemaTransformation.transform({
 	decode: (s) => s.toLowerCase(),
 	encode: (s) => s
-}));
+})));
 const SignatureParams = Schema.Struct({
 	t: TimestampSeconds,
 	s: SignatureHex
@@ -38,7 +44,7 @@ const parseSignatureHeader = (header) => {
 		t: params.get("t") ?? "",
 		s: params.get("s") ?? ""
 	};
-	return Schema.decodeUnknown(SignatureParams)(raw).pipe(Effect.mapError(() => new SignatureError({
+	return Schema.decodeUnknownEffect(SignatureParams)(raw).pipe(Effect.mapError(() => new SignatureError({
 		reason: "invalid_format",
 		message: `Invalid signature format: expected t=<int>&s=<64-hex>, got: ${header}`
 	})));
@@ -47,6 +53,17 @@ const extractKeyBytes = (signingKey) => {
 	const keyWithoutPrefix = signingKey.replace(/^signkey-\w+-/, "");
 	return Buffer.from(keyWithoutPrefix, "hex");
 };
+/**
+* SHA-256 hex of the signing key with the `signkey-{prefix}-` prefix stripped.
+* Used as the Bearer token for outbound requests to the Inngest API per spec
+* §4.1.1.
+*
+* @internal
+*/
+const hashSigningKey = (signingKey) => {
+	const keyWithoutPrefix = signingKey.replace(/^signkey-\w+-/, "");
+	return Crypto.createHash("sha256").update(keyWithoutPrefix).digest("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;
@@ -62,8 +79,8 @@ const checkSignature = (signature, body, timestamp, signingKey) => {
 /**
 * @internal
 */
-const SignatureLive = Layer.effect(Signature, Effect.succeed({
-	verify: ({ body, signatureHeader, signingKey, signingKeyFallback, isDev }) => Effect.gen(function* () {
+const SignatureLive = Layer.succeed(Signature, {
+	verify: Effect.fn("Signature.verify")(function* ({ body, signatureHeader, signingKey, signingKeyFallback, isDev }) {
 		if (isDev) return true;
 		if (!signingKey) return yield* new SignatureError({
 			reason: "missing_signing_key",
@@ -76,7 +93,7 @@ const SignatureLive = Layer.effect(Signature, Effect.succeed({
 		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({
+		if (Math.abs(now.epochMilliseconds - timestampMs) > SIGNATURE_VALIDITY_WINDOW_MS) return yield* new SignatureError({
 			reason: "expired",
 			message: `Signature expired: timestamp ${timestampSeconds} is outside the validity window`
 		});
@@ -88,10 +105,9 @@ const SignatureLive = Layer.effect(Signature, Effect.succeed({
 		});
 	}),
 	sign: (body, signingKey) => DateTime.now.pipe(Effect.map((now) => {
-		const ts = Math.floor(now.epochMillis / 1e3);
+		const ts = Math.floor(now.epochMilliseconds / 1e3);
 		return `t=${ts}&s=${computeSignature(extractKeyBytes(signingKey), body, String(ts))}`;
 	}))
-}));
-
+});
 //#endregion
-export { Signature, SignatureError, SignatureLive };
+export { Signature, SignatureError, SignatureLive, hashSigningKey };

package/dist/internal/step.d.ts

@@ -1,15 +1,9 @@
 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;
@@ -17,27 +11,27 @@ interface StepOptions {
 }
 type StepOptionsOrId = string | StepOptions;
 interface WaitForEventOptions {
-  readonly timeout: Duration.DurationInput;
+  readonly timeout: Duration.Input;
   readonly if?: string;
 }
 interface InvokeOptionsBase<F extends InngestFunction.Any> {
   readonly function: F;
   readonly user?: Record<string, unknown>;
   readonly v?: string;
-  readonly timeout?: Duration.DurationInput;
+  readonly timeout?: Duration.Input;
 }
 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 EventSchema = Schema.Top & {
+  readonly identifier: 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 sleep: (id: StepOptionsOrId, duration: Duration.Input) => 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>;