effect-inngest 0.1.0 → 0.1.2

package/README.md

@@ -124,11 +124,12 @@ class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcom
 // 2. Define your functions
 const ProcessSignup = InngestFunction.make("process-signup", {
   trigger: { event: UserSignup },
-  success: { welcomed: Schema.Boolean },
+  success: Schema.Struct({ welcomed: Schema.Boolean }),
 });
 
 const DailyDigest = InngestFunction.make("daily-digest", {
   trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
 });
 
 // 3. Create function group and implement handlers
@@ -161,15 +162,13 @@ const Client = InngestClient.layer({
   mode: "dev",
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
-const Server = Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const app = yield* InngestGroup.toHttpApp(App);
-    return HttpServer.serve(app, HttpMiddleware.logger).pipe(
-      HttpServer.withLogAddress,
-      Layer.provide(BunHttpServer.layer({ port: 3000 })),
-    );
-  }),
-).pipe(Layer.provide(Handlers), Layer.provide(Client), Layer.provide(FetchHttpClient.layer));
+const Server = HttpServer.serve(InngestGroup.toHttpApp(App), HttpMiddleware.logger).pipe(
+  HttpServer.withLogAddress,
+  Layer.provide(BunHttpServer.layer({ port: 3000 })),
+  Layer.provide(Handlers),
+  Layer.provide(Client),
+  Layer.provide(FetchHttpClient.layer),
+);
 
 // Run it
 BunRuntime.runMain(Layer.launch(Server));
@@ -187,6 +186,78 @@ bunx inngest-cli@latest dev -u http://localhost:3000
 
 Open http://localhost:8288 to trigger events and watch your functions run.
 
+### Using HttpApiBuilder
+
+For more complex applications, you can compose Inngest into an existing `HttpApi`:
+
+```typescript
+import * as HttpApi from "@effect/platform/HttpApi";
+import * as HttpApiBuilder from "@effect/platform/HttpApiBuilder";
+import { FetchHttpClient } from "@effect/platform";
+import { BunHttpServer, BunRuntime } from "@effect/platform-bun";
+import { Duration, Effect, Layer, Schema } from "effect";
+import { InngestApiGroup, layerGroup } from "effect-inngest/HttpApi";
+import { InngestClient, InngestFunction, InngestGroup } from "effect-inngest";
+
+// 1. Define your events
+class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
+  userId: Schema.String,
+  email: Schema.String,
+}) {}
+
+class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcome-sent", {
+  userId: Schema.String,
+}) {}
+
+// 2. Define functions
+const ProcessSignup = InngestFunction.make("process-signup", {
+  trigger: { event: UserSignup },
+  success: Schema.Struct({ welcomed: Schema.Boolean }),
+});
+
+const DailyDigest = InngestFunction.make("daily-digest", {
+  trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
+});
+
+// 3. Create group and handlers
+const App = InngestGroup.make(ProcessSignup, DailyDigest);
+
+const Handlers = App.toLayer({
+  "process-signup": ({ event, step }) =>
+    Effect.gen(function* () {
+      yield* Effect.log(`Processing signup for ${event.email}`);
+      const user = yield* step.run("create-user", Effect.succeed({ id: event.userId, email: event.email }));
+      yield* step.sleep("welcome-delay", Duration.seconds(5));
+      yield* step.sendEvent("notify", new UserWelcomeSent({ userId: user.id }));
+      return { welcomed: true };
+    }),
+  "daily-digest": ({ step }) => step.run("send-digest", Effect.log("Sending daily digest...")),
+});
+
+// 4. Create client
+const Client = InngestClient.layer({
+  id: "my-app",
+  mode: "dev",
+}).pipe(Layer.provide(FetchHttpClient.layer));
+
+// 5. Create API with Inngest group at /inngest prefix
+const MyApi = HttpApi.make("my-api").add(InngestApiGroup.prefix("/inngest"));
+
+// 6. Build API layer
+const ApiLive = HttpApiBuilder.api(MyApi).pipe(
+  Layer.provide(layerGroup(MyApi, App)),
+  Layer.provide(Handlers),
+  Layer.provide(Client),
+  Layer.provide(FetchHttpClient.layer),
+);
+
+// 7. Serve
+const Server = HttpApiBuilder.serve().pipe(Layer.provide(ApiLive), Layer.provide(BunHttpServer.layer({ port: 3000 })));
+
+BunRuntime.runMain(Layer.launch(Server));
+```
+
 ---
 
 ## Getting Started
@@ -217,12 +288,13 @@ import { InngestFunction } from "effect-inngest";
 // Event-triggered function
 const ProcessSignup = InngestFunction.make("process-signup", {
   trigger: [{ event: UserSignup }], // pass multiple triggers as Array.
-  success: { welcomeEmailSent: Schema.Boolean },
+  success: Schema.Struct({ welcomeEmailSent: Schema.Boolean }),
 });
 
 // Cron-triggered function
 const DailyReport = InngestFunction.make("daily-report", {
   trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
 });
 ```
 
@@ -420,19 +492,6 @@ yield * new RetryAfterError({ message: "Rate limited", retryAfter: 60000 });
 
 See the [`examples/`](./examples) directory:
 
-| Example                                     | Description                                    |
-| ------------------------------------------- | ---------------------------------------------- |
-| [simple.ts](./examples/simple.ts)           | Minimal hello world with parallel steps        |
-| [KitchenSink.ts](./examples/KitchenSink.ts) | Complete e-commerce workflow with all features |
-
-```bash
-# Run an example
-bun examples/simple.ts
-
-# Start Inngest dev server
-bunx inngest-cli@latest dev -u http://localhost:9999
-```
-
 ---
 
 ## Current Limitations
@@ -447,11 +506,6 @@ This library is under active development. The following Inngest features are **n
 
 ---
 
-## Requirements
-
-- **TypeScript** 5.4+ with `strict: true`
-- **Effect** 3.x
-
 ## License
 
 MIT

package/dist/Function.d.ts

@@ -313,6 +313,40 @@ interface FunctionRegistration {
     start?: string;
     finish?: string;
   };
+  readonly rateLimit?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+  };
+  readonly throttle?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+    readonly burst?: number;
+  };
+  readonly debounce?: {
+    readonly key?: string;
+    readonly period: string;
+    readonly timeout?: string;
+  };
+  readonly concurrency?: ReadonlyArray<{
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  }>;
+  readonly priority?: {
+    readonly run?: string;
+  };
+  readonly singleton?: {
+    readonly key?: string;
+    readonly mode: string;
+  };
+  readonly batchEvents?: {
+    readonly maxSize: number;
+    readonly timeout: string;
+    readonly key?: string;
+  };
+  readonly idempotency?: string;
 }
 /**
  * An Inngest function definition.

package/dist/Function.js

@@ -35,6 +35,38 @@ const Proto = {
 			start: opts.timeouts.start ? timeStr(opts.timeouts.start) : void 0,
 			finish: opts.timeouts.finish ? timeStr(opts.timeouts.finish) : void 0
 		} : void 0;
+		const rateLimit = opts.rateLimit ? {
+			key: opts.rateLimit.key,
+			limit: opts.rateLimit.limit,
+			period: timeStr(opts.rateLimit.period)
+		} : void 0;
+		const throttle = opts.throttle ? {
+			key: opts.throttle.key,
+			limit: opts.throttle.limit,
+			period: timeStr(opts.throttle.period),
+			burst: opts.throttle.burst
+		} : void 0;
+		const debounce = opts.debounce ? {
+			key: opts.debounce.key,
+			period: timeStr(opts.debounce.period),
+			timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : void 0
+		} : void 0;
+		const concurrency = opts.concurrency != null ? typeof opts.concurrency === "number" ? [{ limit: opts.concurrency }] : Array.ensure(opts.concurrency).map((c) => ({
+			key: c.key,
+			limit: c.limit,
+			scope: c.scope
+		})) : void 0;
+		const priority = opts.priority ? { run: opts.priority.run } : void 0;
+		const singleton = opts.singleton ? {
+			key: opts.singleton.key,
+			mode: opts.singleton.mode
+		} : void 0;
+		const batchEvents = opts.batchEvents ? {
+			maxSize: opts.batchEvents.maxSize,
+			timeout: timeStr(opts.batchEvents.timeout),
+			key: opts.batchEvents.key
+		} : void 0;
+		const idempotency = opts.idempotency;
 		const fnId = `${config.appId}-${this._tag}`;
 		const stepUrl = new URL(config.url);
 		stepUrl.searchParams.set("fnId", fnId);
@@ -53,7 +85,15 @@ const Proto = {
 				retries: { attempts: opts.retries ?? 3 }
 			} },
 			cancel: cancel && cancel.length > 0 ? cancel : void 0,
-			timeouts
+			timeouts,
+			rateLimit,
+			throttle,
+			debounce,
+			concurrency,
+			priority,
+			singleton,
+			batchEvents,
+			idempotency
 		};
 	}
 };

package/dist/Group.d.ts

@@ -143,9 +143,8 @@ declare const toHttpApp: (group: InngestGroup.Any) => HttpApp.Default<never, Inn
  */
 declare const toWebHandler: <R, E>(group: InngestGroup.Any, options: {
   readonly layer: Layer.Layer<InngestClient | HttpClient.HttpClient | R, E, never>;
-  readonly memoMap?: Layer.MemoMap;
 }) => {
-  readonly handler: (request: Request) => Promise<Response>;
+  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
   readonly dispose: () => Promise<void>;
 };
 //#endregion

package/dist/Group.js

@@ -158,7 +158,7 @@ const toHttpApp = (group) => Effect.gen(function* () {
 * process.on("SIGTERM", dispose)
 * ```
 */
-const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope), { memoMap: options.memoMap });
+const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));
 
 //#endregion
 export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/dist/HttpApi.d.ts

@@ -24,20 +24,20 @@ declare class FunctionNotFoundError extends FunctionNotFoundError_base {}
  * @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 mode: "cloud" | "dev";
   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 env: string | null;
   readonly event_api_origin: string;
   readonly event_key_hash: string | null;
   readonly framework: string;
@@ -48,11 +48,11 @@ declare const InngestApiGroup: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpo
   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 mode: "cloud" | "dev";
   readonly schema_version: "2024-05-24";
   readonly extra?: {
     readonly [x: string]: unknown;

package/dist/internal/protocol.js

@@ -6,18 +6,14 @@ import * as Schema$1 from "effect/Schema";
 * 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);
+const stripTopLevelTag = (value) => {
+	if (Predicate.isRecord(value)) return Struct.omit(value, "_tag");
 	return value;
 };
 const WireUnknown = Schema$1.transform(Schema$1.Unknown, Schema$1.Unknown, {
 	strict: true,
 	decode: (value) => value,
-	encode: (value) => stripTags(value)
+	encode: (value) => stripTopLevelTag(value)
 });
 const Opcode = {
 	None: "None",

package/dist/internal/step.js

@@ -8,7 +8,7 @@ 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 Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
 import * as Arr from "effect/Array";
 import * as HashMap from "effect/HashMap";
@@ -38,6 +38,11 @@ const errorOtelAttributes = (err) => {
 	} else attrs[OtelAttributes.ExceptionMessage] = String(err);
 	return attrs;
 };
+const encodeTaggedEvent = (event) => {
+	const ctor = event.constructor;
+	if (Schema.isSchema(ctor)) return Schema.encode(ctor)(event).pipe(Effect.orElseSucceed(() => event));
+	return Effect.succeed(event);
+};
 var Step = class extends Context.Tag("effect-inngest/Step")() {};
 const normalizeOpts = (opts) => typeof opts === "string" ? {
 	id: opts,
@@ -89,16 +94,20 @@ const createStepTools = (request, appName, stepIdCounts) => {
 		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 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", () => {
+		const rawData = Predicate.hasProperty(options, "data") ? options.data : void 0;
+		const encodeData = rawData ? encodeTaggedEvent(rawData) : Effect.succeed(void 0);
+		return Effect.flatMap(encodeData, (encodedData) => Effect.fail(invokeInterrupt({
+			info,
+			functionId: `${appName}-${options.function._tag}`,
+			payload: {
+				data: encodedData,
+				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: {
@@ -132,17 +141,17 @@ const createStepTools = (request, appName, stepIdCounts) => {
 		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) => ({
+		const events = Arr.ensure(payload);
+		return Effect.flatMap(Effect.forEach(events, (e) => Effect.map(encodeTaggedEvent(e), (encoded) => ({
 			name: e._tag,
-			data: e
-		}));
-		return Effect.flatMap(InngestClient, (client) => client.sendEvent(eventPayloads).pipe(Effect.withSpan(`inngest.step/sendEvent/${info.id}`, { attributes: {
+			data: encoded
+		}))), (eventPayloads) => 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-inngest",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
   "keywords": [
     "background-jobs",
@@ -23,9 +23,6 @@
     "type": "git",
     "url": "https://github.com/erikshestopal/effect-inngest.git"
   },
-  "workspaces": [
-    "examples"
-  ],
   "files": [
     "dist/**/*.d.ts",
     "dist/**/*.d.ts.map",
@@ -106,16 +103,21 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
+    "@effect/cluster": "^0.56.1",
     "@effect/language-service": "0.72.0",
+    "@effect/platform": "^0.94.2",
+    "@effect/platform-bun": "^0.87.0",
     "@types/bun": "1.3.6",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "effect": "^3.15.0",
     "oxfmt": "0.26.0",
     "oxlint": "1.41.0",
     "oxlint-tsgolint": "0.11.1",
-    "tsdown": "0.20.1"
+    "tsdown": "0.20.1",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@effect/platform": ">=0.80.0",
-    "effect": ">=3.14.0"
+    "@effect/platform": ">=0.87.0",
+    "effect": ">=3.15.0"
   }
 }

package/src/Function.ts

@@ -331,7 +331,11 @@ interface RegistrationConfig {
 interface FunctionRegistration {
   readonly id: string;
   readonly name: string;
-  readonly triggers: ReadonlyArray<{ event?: string; cron?: string; expression?: string }>;
+  readonly triggers: ReadonlyArray<{
+    event?: string;
+    cron?: string;
+    expression?: string;
+  }>;
   readonly steps: {
     readonly step: {
       readonly id: string;
@@ -340,8 +344,41 @@ interface FunctionRegistration {
       readonly retries?: { readonly attempts: number };
     };
   };
-  readonly cancel?: ReadonlyArray<{ event: string; if?: string; timeout?: string }>;
+  readonly cancel?: ReadonlyArray<{
+    event: string;
+    if?: string;
+    timeout?: string;
+  }>;
   readonly timeouts?: { start?: string; finish?: string };
+  readonly rateLimit?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+  };
+  readonly throttle?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+    readonly burst?: number;
+  };
+  readonly debounce?: {
+    readonly key?: string;
+    readonly period: string;
+    readonly timeout?: string;
+  };
+  readonly concurrency?: ReadonlyArray<{
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  }>;
+  readonly priority?: { readonly run?: string };
+  readonly singleton?: { readonly key?: string; readonly mode: string };
+  readonly batchEvents?: {
+    readonly maxSize: number;
+    readonly timeout: string;
+    readonly key?: string;
+  };
+  readonly idempotency?: string;
 }
 
 /**
@@ -392,7 +429,11 @@ const Proto = {
   [TypeId]: TypeId,
 
   toRegistration(this: InngestFunction.Any, config: RegistrationConfig): FunctionRegistration {
-    const triggers: Array<{ event?: string; cron?: string; expression?: string }> = [];
+    const triggers: Array<{
+      event?: string;
+      cron?: string;
+      expression?: string;
+    }> = [];
 
     for (const t of this.triggers) {
       if (isEventTrigger(t)) {
@@ -416,6 +457,54 @@ const Proto = {
           }
         : undefined;
 
+    const rateLimit = opts.rateLimit
+      ? {
+          key: opts.rateLimit.key,
+          limit: opts.rateLimit.limit,
+          period: timeStr(opts.rateLimit.period),
+        }
+      : undefined;
+
+    const throttle = opts.throttle
+      ? {
+          key: opts.throttle.key,
+          limit: opts.throttle.limit,
+          period: timeStr(opts.throttle.period),
+          burst: opts.throttle.burst,
+        }
+      : undefined;
+
+    const debounce = opts.debounce
+      ? {
+          key: opts.debounce.key,
+          period: timeStr(opts.debounce.period),
+          timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : undefined,
+        }
+      : undefined;
+
+    const concurrency =
+      opts.concurrency != null
+        ? typeof opts.concurrency === "number"
+          ? [{ limit: opts.concurrency }]
+          : Arr.ensure(opts.concurrency).map((c) => ({
+              key: c.key,
+              limit: c.limit,
+              scope: c.scope,
+            }))
+        : undefined;
+
+    const priority = opts.priority ? { run: opts.priority.run } : undefined;
+    const singleton = opts.singleton ? { key: opts.singleton.key, mode: opts.singleton.mode } : undefined;
+    const batchEvents = opts.batchEvents
+      ? {
+          maxSize: opts.batchEvents.maxSize,
+          timeout: timeStr(opts.batchEvents.timeout),
+          key: opts.batchEvents.key,
+        }
+      : undefined;
+
+    const idempotency = opts.idempotency;
+
     const fnId = `${config.appId}-${this._tag}`;
     const stepUrl = new URL(config.url);
     stepUrl.searchParams.set("fnId", fnId);
@@ -435,6 +524,14 @@ const Proto = {
       },
       cancel: cancel && cancel.length > 0 ? cancel : undefined,
       timeouts,
+      rateLimit,
+      throttle,
+      debounce,
+      concurrency,
+      priority,
+      singleton,
+      batchEvents,
+      idempotency,
     };
   },
 };

package/src/Group.ts

@@ -303,12 +303,8 @@ export const toWebHandler = <R, E>(
   group: InngestGroup.Any,
   options: {
     readonly layer: Layer.Layer<InngestClient | HttpClient.HttpClient | R, E, never>;
-    readonly memoMap?: Layer.MemoMap;
   },
 ): {
-  readonly handler: (request: Request) => Promise<Response>;
+  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
   readonly dispose: () => Promise<void>;
-} =>
-  HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope), {
-    memoMap: options.memoMap,
-  });
+} => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));

package/src/internal/protocol.ts

@@ -5,13 +5,9 @@
 import { Predicate, Struct } from "effect";
 import * as Schema from "effect/Schema";
 
-const stripTags = (value: unknown): unknown => {
+const stripTopLevelTag = (value: unknown): unknown => {
   if (Predicate.isRecord(value)) {
-    const stripped = Struct.omit(value as Record<string, unknown>, "_tag");
-    return Object.fromEntries(Object.entries(stripped).map(([k, v]) => [k, stripTags(v)]));
-  }
-  if (Array.isArray(value)) {
-    return value.map(stripTags);
+    return Struct.omit(value as Record<string, unknown>, "_tag");
   }
   return value;
 };
@@ -19,7 +15,7 @@ const stripTags = (value: unknown): unknown => {
 const WireUnknown = Schema.transform(Schema.Unknown, Schema.Unknown, {
   strict: true,
   decode: (value) => value,
-  encode: (value) => stripTags(value),
+  encode: (value) => stripTopLevelTag(value),
 });
 
 export const Opcode = {

package/src/internal/step.ts

@@ -86,6 +86,16 @@ type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventType<F
 type EventSchema = Schema.Schema.Any & { readonly _tag: string };
 type TaggedEvent = { readonly _tag: string };
 
+const encodeTaggedEvent = (event: TaggedEvent): Effect.Effect<unknown, never> => {
+  const ctor = event.constructor;
+  if (Schema.isSchema(ctor)) {
+    return Schema.encode(ctor as unknown as Schema.Schema.AnyNoContext)(event).pipe(
+      Effect.orElseSucceed(() => event),
+    );
+  }
+  return Effect.succeed(event);
+};
+
 interface StepTools {
   readonly run: <A, Err, R>(
     id: StepOptionsOrId,
@@ -226,20 +236,24 @@ export const createStepTools = (
         ),
         Match.tag("MemoTimeout", () => stepError(info.id, "Invoke timed out", { noRetry: true })),
         Match.tag("MemoInput", () => Effect.succeed(undefined as InngestFunction.Success<F>)),
-        Match.tag("MemoNone", () =>
-          Effect.fail(
-            invokeInterrupt({
-              info,
-              functionId: `${appName}-${options.function._tag}`,
-              payload: {
-                data: Predicate.hasProperty(options, "data") ? options.data : undefined,
-                user: options.user ?? {},
-                v: options.v ?? "1",
-              },
-              timeout: options.timeout ? timeStr(options.timeout) : "365d",
-            }),
-          ),
-        ),
+        Match.tag("MemoNone", () => {
+          const rawData = Predicate.hasProperty(options, "data") ? (options.data as TaggedEvent) : undefined;
+          const encodeData = rawData ? encodeTaggedEvent(rawData) : Effect.succeed(undefined);
+          return Effect.flatMap(encodeData, (encodedData) =>
+            Effect.fail(
+              invokeInterrupt({
+                info,
+                functionId: `${appName}-${options.function._tag}`,
+                payload: {
+                  data: encodedData,
+                  user: options.user ?? {},
+                  v: options.v ?? "1",
+                },
+                timeout: options.timeout ? timeStr(options.timeout) : "365d",
+              }),
+            ),
+          );
+        }),
         Match.exhaustive,
       ),
     );
@@ -311,15 +325,20 @@ export const createStepTools = (
             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 }))),
+          const events = Arr.ensure(payload);
+          return Effect.flatMap(
+            Effect.forEach(events, (e) =>
+              Effect.map(encodeTaggedEvent(e), (encoded) => ({ name: e._tag, data: encoded })),
             ),
+            (eventPayloads) =>
+              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,