effect-inngest 0.1.0

package/dist/internal/step.js

@@ -0,0 +1,183 @@
+import { formatTimestamp, timeStr } from "./helpers.js";
+import { InngestClient } from "../Client.js";
+import { SendEventError, StepError, isNonRetriableError, isRetryAfterError } from "./errors.js";
+import { StepInterrupt, errorInterrupt, invokeInterrupt, plannedInterrupt, runInterrupt, sleepInterrupt, waitForEventInterrupt } from "./interrupts.js";
+import { OtelAttributes } from "./constants.js";
+import { decodeMemo } from "./memo.js";
+import * as Duration from "effect/Duration";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Arr from "effect/Array";
+import * as HashMap from "effect/HashMap";
+import * as Match from "effect/Match";
+import * as Ref from "effect/Ref";
+import { pipe } from "effect/Function";
+
+//#region src/internal/step.ts
+/**
+* Internal step tools implementation.
+* @internal
+*/
+/** @internal */
+const hashStepId = (id, repeatIndex = 0) => {
+	const effectiveId = repeatIndex > 0 ? `${id}:${repeatIndex}` : id;
+	return Effect.map(Effect.promise(() => globalThis.crypto.subtle.digest("SHA-1", new TextEncoder().encode(effectiveId))), (buffer) => new Uint8Array(buffer).toHex());
+};
+const errorOtelAttributes = (err) => {
+	const attrs = {};
+	if (err instanceof Error) {
+		attrs[OtelAttributes.ExceptionType] = err.name;
+		attrs[OtelAttributes.ExceptionMessage] = err.message;
+		if (err.stack) attrs[OtelAttributes.ExceptionStacktrace] = err.stack;
+	} else if (Predicate.hasProperty(err, "_tag") && typeof err._tag === "string") {
+		attrs[OtelAttributes.ExceptionType] = err._tag;
+		if (Predicate.hasProperty(err, "message") && typeof err.message === "string") attrs[OtelAttributes.ExceptionMessage] = err.message;
+	} else attrs[OtelAttributes.ExceptionMessage] = String(err);
+	return attrs;
+};
+var Step = class extends Context.Tag("effect-inngest/Step")() {};
+const normalizeOpts = (opts) => typeof opts === "string" ? {
+	id: opts,
+	name: opts
+} : {
+	id: opts.id,
+	name: opts.name ?? opts.id
+};
+const stepError = (stepId, message, opts) => Effect.fail(StepError.make({
+	stepId,
+	message,
+	noRetry: opts?.noRetry,
+	cause: opts?.cause
+}));
+const createStepTools = (request, appName, stepIdCounts) => {
+	const ctx = request.ctx;
+	const steps = request.steps;
+	const getInfo = (opts) => {
+		const { id, name } = normalizeOpts(opts);
+		return Effect.flatMap(Ref.modify(stepIdCounts, (map) => {
+			const count = Option.getOrElse(HashMap.get(map, id), () => 0);
+			return [count, HashMap.set(map, id, count + 1)];
+		}), (count) => Effect.map(hashStepId(id, count), (hash) => ({
+			id,
+			name,
+			hash
+		})));
+	};
+	const getMemo = (hash) => decodeMemo(steps[hash]);
+	const canExecute = (hash) => ctx.step_id === hash || ctx.step_id === "step";
+	const isBlocked = (hash) => ctx.disable_immediate_execution && ctx.step_id !== hash;
+	const sleep = (opts, duration) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", () => Effect.void), Match.tag("MemoTimeout", () => Effect.void), Match.tag("MemoError", () => Effect.void), Match.tag("MemoInput", () => Effect.void), Match.tag("MemoNone", () => Effect.fail(sleepInterrupt({
+		info,
+		duration: timeStr(duration)
+	}))), Match.exhaustive));
+	const sleepUntil = (opts, timestamp) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", () => Effect.void), Match.tag("MemoTimeout", () => Effect.void), Match.tag("MemoError", () => Effect.void), Match.tag("MemoInput", () => Effect.void), Match.tag("MemoNone", () => Effect.fail(sleepInterrupt({
+		info,
+		duration: formatTimestamp(timestamp)
+	}))), Match.exhaustive));
+	const waitForEvent = (opts, event, options) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => {
+		if (data == null) return Effect.succeed(Option.none());
+		const event = data;
+		const payload = event.data !== void 0 ? event.data : data;
+		if (payload == null) return Effect.succeed(Option.none());
+		return Effect.succeed(Option.some(payload));
+	}), Match.tag("MemoTimeout", () => Effect.succeed(Option.none())), Match.tag("MemoError", () => Effect.succeed(Option.none())), Match.tag("MemoInput", () => Effect.succeed(Option.none())), Match.tag("MemoNone", () => Effect.fail(waitForEventInterrupt({
+		info,
+		event: event._tag,
+		timeout: timeStr(options.timeout),
+		if: options.if
+	}))), Match.exhaustive));
+	const invoke = (opts, options) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed", { cause: error })), Match.tag("MemoTimeout", () => stepError(info.id, "Invoke timed out", { noRetry: true })), Match.tag("MemoInput", () => Effect.succeed(void 0)), Match.tag("MemoNone", () => Effect.fail(invokeInterrupt({
+		info,
+		functionId: `${appName}-${options.function._tag}`,
+		payload: {
+			data: Predicate.hasProperty(options, "data") ? options.data : void 0,
+			user: options.user ?? {},
+			v: options.v ?? "1"
+		},
+		timeout: options.timeout ? timeStr(options.timeout) : "365d"
+	}))), Match.exhaustive));
+	const run = (opts, effect) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Step failed", { noRetry: true })), Match.tag("MemoTimeout", () => stepError(info.id, "Step timed out", { noRetry: true })), Match.tag("MemoInput", () => stepError(info.id, "Unexpected step result type: input")), Match.tag("MemoNone", () => {
+		if (isBlocked(info.hash) || !canExecute(info.hash)) return Effect.fail(plannedInterrupt({ info }));
+		return effect.pipe(Effect.withSpan(`inngest.step/run/${info.id}`, { attributes: {
+			[OtelAttributes.StepId]: info.id,
+			[OtelAttributes.StepType]: "run"
+		} }), Effect.matchEffect({
+			onFailure: (err) => {
+				const noRetry = isNonRetriableError(err) ? true : void 0;
+				const retryAfterMs = isRetryAfterError(err) ? Duration.toMillis(err.retryAfter) : void 0;
+				return Effect.zipRight(Effect.annotateCurrentSpan(errorOtelAttributes(err)), Effect.fail(errorInterrupt({
+					info,
+					error: err,
+					noRetry,
+					retryAfterMs
+				})));
+			},
+			onSuccess: (data) => Effect.fail(runInterrupt({
+				info,
+				data
+			}))
+		}), Effect.catchAllDefect((defect) => Effect.zipRight(Effect.annotateCurrentSpan(errorOtelAttributes(defect)), Effect.fail(errorInterrupt({
+			info,
+			error: defect
+		})))));
+	}), Match.exhaustive));
+	const sendEvent = (opts, payload) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", () => Effect.fail(SendEventError.make({
+		message: "SendEvent failed",
+		events: []
+	}))), Match.tag("MemoTimeout", () => Effect.fail(SendEventError.make({
+		message: "SendEvent timed out",
+		events: []
+	}))), Match.tag("MemoInput", () => Effect.succeed({ ids: [] })), Match.tag("MemoNone", () => {
+		if (isBlocked(info.hash) || !canExecute(info.hash)) return Effect.fail(plannedInterrupt({ info }));
+		const eventPayloads = Arr.map(Arr.ensure(payload), (e) => ({
+			name: e._tag,
+			data: e
+		}));
+		return Effect.flatMap(InngestClient, (client) => client.sendEvent(eventPayloads).pipe(Effect.withSpan(`inngest.step/sendEvent/${info.id}`, { attributes: {
+			[OtelAttributes.StepId]: info.id,
+			[OtelAttributes.StepType]: "sendEvent"
+		} }), Effect.flatMap((result) => Effect.fail(runInterrupt({
+			info,
+			data: result
+		})))));
+	}), Match.exhaustive));
+	return {
+		run,
+		sleep,
+		sleepUntil,
+		waitForEvent,
+		invoke,
+		sendEvent
+	};
+};
+const buildHandlerContext = (fn, step, request) => {
+	if (fn.options?.batchEvents != null) return {
+		event: request.events.map((e) => e.data),
+		step,
+		run: {
+			id: request.ctx.run_id,
+			attempt: request.ctx.attempt,
+			maxAttempts: request.ctx.max_attempts
+		}
+	};
+	let eventData = request.event.data;
+	if (request.event.name === "inngest/function.invoked" && typeof eventData === "object" && eventData !== null) {
+		const { _inngest, ...payload } = eventData;
+		eventData = payload;
+	}
+	return {
+		event: eventData,
+		step,
+		run: {
+			id: request.ctx.run_id,
+			attempt: request.ctx.attempt,
+			maxAttempts: request.ctx.max_attempts
+		}
+	};
+};
+
+//#endregion
+export { Step, buildHandlerContext, createStepTools };

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "effect-inngest",
+  "version": "0.1.0",
+  "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
+  "keywords": [
+    "background-jobs",
+    "durable",
+    "effect",
+    "event-driven",
+    "inngest",
+    "queue",
+    "serverless",
+    "typescript",
+    "workflow"
+  ],
+  "homepage": "https://github.com/erikshestopal/effect-inngest#readme",
+  "bugs": {
+    "url": "https://github.com/erikshestopal/effect-inngest/issues"
+  },
+  "license": "MIT",
+  "author": "Erik Shestopal",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/erikshestopal/effect-inngest.git"
+  },
+  "workspaces": [
+    "examples"
+  ],
+  "files": [
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "src/**/*.ts"
+  ],
+  "type": "module",
+  "sideEffects": [],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts"
+    },
+    "./Client": {
+      "types": "./dist/Client.d.ts",
+      "import": "./src/Client.ts"
+    },
+    "./Events": {
+      "types": "./dist/Events.d.ts",
+      "import": "./src/Events.ts"
+    },
+    "./Function": {
+      "types": "./dist/Function.d.ts",
+      "import": "./src/Function.ts"
+    },
+    "./Group": {
+      "types": "./dist/Group.d.ts",
+      "import": "./src/Group.ts"
+    },
+    "./HttpApi": {
+      "types": "./dist/HttpApi.d.ts",
+      "import": "./src/HttpApi.ts"
+    },
+    "./internal/*": null
+  },
+  "publishConfig": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./Client": {
+        "types": "./dist/Client.d.ts",
+        "import": "./dist/Client.js"
+      },
+      "./Events": {
+        "types": "./dist/Events.d.ts",
+        "import": "./dist/Events.js"
+      },
+      "./Function": {
+        "types": "./dist/Function.d.ts",
+        "import": "./dist/Function.js"
+      },
+      "./Group": {
+        "types": "./dist/Group.d.ts",
+        "import": "./dist/Group.js"
+      },
+      "./HttpApi": {
+        "types": "./dist/HttpApi.d.ts",
+        "import": "./dist/HttpApi.js"
+      },
+      "./internal/*": null
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "format": "oxfmt",
+    "lint": "oxlint --fix --type-aware --type-check --promise-plugin",
+    "typecheck": "tsgo --noEmit",
+    "prepare": "effect-language-service patch",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "changeset:publish": "bun run build && changeset publish"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@effect/language-service": "0.72.0",
+    "@types/bun": "1.3.6",
+    "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "oxfmt": "0.26.0",
+    "oxlint": "1.41.0",
+    "oxlint-tsgolint": "0.11.1",
+    "tsdown": "0.20.1"
+  },
+  "peerDependencies": {
+    "@effect/platform": ">=0.80.0",
+    "effect": ">=3.14.0"
+  }
+}

package/src/Client.ts

@@ -0,0 +1,279 @@
+/**
+ * @since 0.1.0
+ */
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Config from "effect/Config";
+import type * as ConfigError from "effect/ConfigError";
+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 Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Protocol from "./internal/protocol.js";
+
+/**
+ * @since 0.1.0
+ * @category type ids
+ * @internal
+ */
+const TypeId: unique symbol = Symbol.for("effect-inngest/Client");
+
+/**
+ * @since 0.1.0
+ * @category type ids
+ * @internal
+ */
+type TypeId = typeof TypeId;
+
+const DEFAULT_EVENT_BASE_URL = "https://inn.gs/";
+const DEFAULT_API_BASE_URL = "https://api.inngest.com/";
+const DEFAULT_DEV_SERVER_URL = "http://localhost:8288/";
+const SDK_VERSION = "2.0.0";
+
+type ClientMode = "dev" | "cloud";
+
+interface ClientConfig {
+  /**
+   * The ID of this instance, most commonly a reference to the application it
+   * resides in.
+   *
+   * The ID of your client should remain the same for its lifetime; if you'd
+   * like to change the name of your client as it appears in the Inngest UI,
+   * change the `name` property instead.
+   */
+  readonly id: string;
+
+  /**
+   * Inngest event key, used to send events to Inngest Cloud. If not provided,
+   * will search for the `INNGEST_EVENT_KEY` environment variable. If neither
+   * can be found, a warning will be shown and any attempts to send events in
+   * cloud mode will throw an error.
+   */
+  readonly eventKey?: string | undefined;
+
+  /**
+   * Inngest signing key, used for request signature verification.
+   * If not provided, will search for the `INNGEST_SIGNING_KEY` environment variable.
+   */
+  readonly signingKey?: string | undefined;
+
+  /**
+   * Fallback signing key for key rotation scenarios.
+   * If not provided, will search for the `INNGEST_SIGNING_KEY_FALLBACK` environment variable.
+   */
+  readonly signingKeyFallback?: string | undefined;
+
+  /**
+   * The base URL for the Inngest API (registration, run fetching, etc.)
+   * Defaults to https://api.inngest.com/ in cloud mode.
+   */
+  readonly apiBaseUrl?: string | undefined;
+
+  /**
+   * The base URL for sending events.
+   * Defaults to https://inn.gs/ in cloud mode.
+   */
+  readonly eventBaseUrl?: string | undefined;
+
+  /**
+   * Can be used to explicitly set the client to Development Mode or Cloud Mode.
+   * If not set, mode is inferred from environment variables (INNGEST_DEV, NODE_ENV, etc.)
+   *
+   * Development mode will turn off signature verification and default to using
+   * a local URL to access a local Dev Server.
+   */
+  readonly mode?: ClientMode | undefined;
+
+  /**
+   * The Inngest environment to send events to. Defaults to whichever
+   * environment this client's event key is associated with.
+   *
+   * It's likely you never need to change this unless you're trying to sync
+   * multiple systems together using branch names.
+   */
+  readonly env?: string | undefined;
+
+  /**
+   * The application-specific version identifier. This can be an arbitrary value
+   * such as a version string, a Git commit SHA, or any other unique identifier.
+   */
+  readonly appVersion?: string | undefined;
+
+  /**
+   * The host where this app is served. Used for registration.
+   */
+  readonly serveHost?: string | undefined;
+
+  /**
+   * The path where the Inngest serve handler is mounted. Used for registration.
+   */
+  readonly servePath?: string | undefined;
+}
+
+export const EventPayload = Schema.Struct({
+  name: Schema.String,
+  data: Schema.Unknown,
+  ts: Schema.optional(Schema.Number),
+  id: Schema.optional(Schema.String),
+  v: Schema.optional(Schema.String),
+});
+
+const SendEventResponse = Schema.Struct({
+  ids: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
+  status: Schema.optional(Schema.Number),
+});
+
+type EventPayload = typeof EventPayload.Type;
+type SendEventResponse = typeof SendEventResponse.Type;
+
+class SendEventError extends Schema.TaggedError<SendEventError>()("SendEventError", {
+  message: Schema.String,
+  events: Schema.Array(Schema.String),
+}) {}
+
+interface InngestClientService {
+  readonly [TypeId]: TypeId;
+  readonly config: ClientConfig;
+  readonly mode: ClientMode;
+  readonly eventBaseUrl: string;
+  readonly apiBaseUrl: string;
+  readonly sendEvent: (events: ReadonlyArray<EventPayload>) => Effect.Effect<SendEventResponse, SendEventError>;
+}
+
+/**
+ * InngestClient service for communicating with Inngest.
+ *
+ * @since 0.1.0
+ * @category context
+ */
+export class InngestClient extends Context.Tag("effect-inngest/InngestClient")<InngestClient, InngestClientService>() {}
+
+const resolveMode = (config: ClientConfig): ClientMode => config.mode ?? "dev";
+
+const resolveEventBaseUrl = (config: ClientConfig, mode: ClientMode): string =>
+  config.eventBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_EVENT_BASE_URL);
+
+const resolveApiBaseUrl = (config: ClientConfig, mode: ClientMode): string =>
+  config.apiBaseUrl ?? (mode === "dev" ? DEFAULT_DEV_SERVER_URL : DEFAULT_API_BASE_URL);
+
+const makeClient = (config: ClientConfig, httpClient: HttpClient.HttpClient): InngestClientService => {
+  const mode = resolveMode(config);
+  const eventBaseUrl = resolveEventBaseUrl(config, mode);
+  const apiBaseUrl = resolveApiBaseUrl(config, mode);
+
+  const sendEvent = (events: ReadonlyArray<EventPayload>): Effect.Effect<SendEventResponse, SendEventError> => {
+    if (!config.eventKey && mode === "cloud") {
+      return new SendEventError({
+        message: "Event key is required to send events in cloud mode",
+        events: events.map((e) => e.name),
+      });
+    }
+
+    const key = config.eventKey ?? "local";
+    const url = new URL(`e/${key}`, eventBaseUrl).toString();
+    const eventNames = events.map((e) => e.name);
+    const now = Date.now();
+
+    const payloads = events.map((e) => ({
+      name: e.name,
+      data: e.data ?? {},
+      ts: e.ts ?? now,
+      id: e.id,
+      v: e.v,
+    }));
+
+    const request = HttpClientRequest.post(url).pipe(
+      HttpClientRequest.setHeaders({
+        "Content-Type": "application/json",
+        [Protocol.Headers.SDK]: `effect-ts:v${SDK_VERSION}`,
+        ...(config.env ? { [Protocol.Headers.Env]: config.env } : {}),
+      }),
+    );
+
+    return HttpClientRequest.schemaBodyJson(Schema.Array(EventPayload))(request, payloads).pipe(
+      Effect.flatMap(httpClient.execute),
+      Effect.flatMap(HttpClientResponse.schemaBodyJson(SendEventResponse)),
+      Effect.map((response) => ({ ids: response.ids, status: response.status })),
+      Effect.scoped,
+      Effect.catchAll(
+        (error) =>
+          new SendEventError({
+            message: `Failed to send events: ${Predicate.hasProperty(error, "message") ? (error.message as string) : "Unknown error"}`,
+            events: eventNames,
+          }),
+      ),
+    );
+  };
+
+  return {
+    [TypeId]: TypeId,
+    config,
+    mode,
+    eventBaseUrl,
+    apiBaseUrl,
+    sendEvent,
+  };
+};
+
+/**
+ * Create an InngestClient layer from a config.
+ *
+ * @since 0.1.0
+ * @category layers
+ * @example
+ * ```ts
+ * const ClientLive = InngestClient.layer({
+ *   id: "my-app",
+ *   eventKey: "my-event-key",
+ * })
+ * ```
+ */
+export const layer = (config: ClientConfig): Layer.Layer<InngestClient, never, HttpClient.HttpClient> =>
+  Layer.effect(
+    InngestClient,
+    Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(config, httpClient)),
+  );
+
+/**
+ * Create an InngestClient layer from Effect Config.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export const layerConfig = (
+  config: Config.Config.Wrap<ClientConfig>,
+): Layer.Layer<InngestClient, ConfigError.ConfigError, HttpClient.HttpClient> =>
+  Layer.effect(
+    InngestClient,
+    Effect.flatMap(Config.unwrap(config), (resolvedConfig) =>
+      Effect.map(HttpClient.HttpClient, (httpClient) => makeClient(resolvedConfig, httpClient)),
+    ),
+  );
+
+/**
+ * Create an InngestClient layer from environment variables.
+ *
+ * Uses:
+ * - INNGEST_APP_ID or "app" as id
+ * - INNGEST_EVENT_KEY for event key
+ * - INNGEST_SIGNING_KEY for signing key
+ *
+ * Mode is inferred from environment (INNGEST_DEV, NODE_ENV, etc.)
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export const layerFromEnv: Layer.Layer<InngestClient, ConfigError.ConfigError, HttpClient.HttpClient> = layerConfig(
+  Config.all({
+    id: Config.string("INNGEST_APP_ID").pipe(Config.withDefault("app")),
+    eventKey: Config.string("INNGEST_EVENT_KEY").pipe(Config.option, Config.map(Option.getOrUndefined)),
+    signingKey: Config.string("INNGEST_SIGNING_KEY").pipe(Config.option, Config.map(Option.getOrUndefined)),
+    signingKeyFallback: Config.string("INNGEST_SIGNING_KEY_FALLBACK").pipe(
+      Config.option,
+      Config.map(Option.getOrUndefined),
+    ),
+  }),
+);

package/src/Events.ts

@@ -0,0 +1,87 @@
+/**
+ * Internal Inngest events that the platform sends automatically.
+ * Use these as triggers to react to function lifecycle events.
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+
+/**
+ * Error structure used in internal Inngest events.
+ * @since 0.1.0
+ */
+export class JsonError extends Schema.Class<JsonError>("JsonError")({
+  name: Schema.String,
+  message: Schema.String,
+  stack: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Unknown),
+}) {}
+
+/**
+ * Sent when a function fails after exhausting all retries.
+ * Trigger on this to handle failures (e.g., alerting, cleanup).
+ * @since 0.1.0
+ */
+export class FunctionFailed extends Schema.TaggedClass<FunctionFailed>()("inngest/function.failed", {
+  function_id: Schema.String,
+  run_id: Schema.String,
+  error: JsonError,
+  event: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+}) {}
+
+/**
+ * Sent when a function finishes with an error.
+ * @since 0.1.0
+ */
+export class FunctionFinishedError extends Schema.TaggedClass<FunctionFinishedError>()("inngest/function.finished", {
+  function_id: Schema.String,
+  run_id: Schema.String,
+  correlation_id: Schema.optional(Schema.String),
+  error: JsonError,
+}) {}
+
+/**
+ * Sent when a function finishes successfully.
+ * @since 0.1.0
+ */
+export class FunctionFinishedSuccess extends Schema.TaggedClass<FunctionFinishedSuccess>()(
+  "inngest/function.finished",
+  {
+    function_id: Schema.String,
+    run_id: Schema.String,
+    correlation_id: Schema.optional(Schema.String),
+    result: Schema.Unknown,
+  },
+) {}
+
+/**
+ * Union of both FunctionFinished variants.
+ * @since 0.1.0
+ */
+export const FunctionFinished = Schema.Union(FunctionFinishedError, FunctionFinishedSuccess);
+export type FunctionFinished = typeof FunctionFinished.Type;
+
+/**
+ * Sent when a function is cancelled.
+ * @since 0.1.0
+ */
+export class FunctionCancelled extends Schema.TaggedClass<FunctionCancelled>()("inngest/function.cancelled", {
+  function_id: Schema.String,
+  run_id: Schema.String,
+  correlation_id: Schema.optional(Schema.String),
+}) {}
+
+/**
+ * Sent when a function is invoked via step.invoke().
+ * @since 0.1.0
+ */
+export class FunctionInvoked extends Schema.TaggedClass<FunctionInvoked>()("inngest/function.invoked", {
+  data: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+}) {}
+
+/**
+ * Sent when a cron trigger fires.
+ * @since 0.1.0
+ */
+export class ScheduledTimer extends Schema.TaggedClass<ScheduledTimer>()("inngest/scheduled.timer", {
+  cron: Schema.String,
+}) {}