effect-inngest 0.1.3 → 0.2.0-beta.0

package/src/internal/protocol.ts

@@ -2,21 +2,25 @@
  * Wire protocol schemas and opcode factories for Inngest communication.
  * @internal
  */
-import { Predicate, Struct } from "effect";
+import { Effect, Predicate, SchemaTransformation, Struct } from "effect";
 import * as Schema from "effect/Schema";
 
 const stripTopLevelTag = (value: unknown): unknown => {
-  if (Predicate.isRecord(value)) {
-    return Struct.omit(value as Record<string, unknown>, "_tag");
+  if (Predicate.isObject(value)) {
+    return Struct.omit(value as Record<string, unknown>, ["_tag"]);
   }
   return value;
 };
 
-const WireUnknown = Schema.transform(Schema.Unknown, Schema.Unknown, {
-  strict: true,
-  decode: (value) => value,
-  encode: (value) => stripTopLevelTag(value),
-});
+const WireUnknown = Schema.Unknown.pipe(
+  Schema.decodeTo(
+    Schema.Unknown,
+    SchemaTransformation.transform({
+      decode: (value) => value,
+      encode: (value) => stripTopLevelTag(value),
+    }),
+  ),
+);
 
 export const Opcode = {
   None: "None",
@@ -48,9 +52,7 @@ export class UserError extends Schema.Class<UserError>("UserError")({
 }) {}
 
 export const StepResult = Schema.NullOr(
-  Schema.Record({ key: Schema.String, value: Schema.Unknown }).pipe(
-    Schema.annotations({ identifier: "StepResultObject" }),
-  ),
+  Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.annotate({ identifier: "StepResultObject" })),
 );
 
 export class FunctionStack extends Schema.Class<FunctionStack>("FunctionStack")({
@@ -61,36 +63,37 @@ export class FunctionStack extends Schema.Class<FunctionStack>("FunctionStack")(
 export class InngestEvent extends Schema.Class<InngestEvent>("InngestEvent")({
   id: Schema.optional(Schema.String),
   name: Schema.String,
-  data: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Unknown }), {
-    default: () => ({}),
-    nullable: true,
-  }),
+  data: Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown)).pipe(
+    Schema.withDecodingDefaultType(Effect.succeed({})),
+  ),
 
   ts: Schema.optional(Schema.Number),
-  user: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+  user: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   v: Schema.optional(Schema.String),
 }) {}
 
 export class SDKRequestContext extends Schema.Class<SDKRequestContext>("SDKRequestContext")({
   fn_id: Schema.String,
   run_id: Schema.String,
-  env: Schema.optionalWith(Schema.String, { default: () => "dev" }),
-  step_id: Schema.optionalWith(Schema.String, { default: () => "step" }),
-  attempt: Schema.optionalWith(Schema.Number, { default: () => 0 }),
-  max_attempts: Schema.optionalWith(Schema.Number, { default: () => 4 }),
-  stack: Schema.optionalWith(FunctionStack, { default: () => FunctionStack.make({ stack: [], current: 0 }) }),
-  qi_id: Schema.optionalWith(Schema.String, { default: () => "" }),
-  disable_immediate_execution: Schema.optionalWith(Schema.Boolean, { default: () => false }),
-  use_api: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+  env: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("dev"))),
+  step_id: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("step"))),
+  attempt: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+  max_attempts: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(4))),
+  stack: FunctionStack.pipe(
+    Schema.withDecodingDefaultType(Effect.succeed(FunctionStack.make({ stack: [], current: 0 }))),
+  ),
+  qi_id: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+  disable_immediate_execution: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+  use_api: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
 }) {}
 
 export class SDKRequestBody extends Schema.Class<SDKRequestBody>("SDKRequestBody")({
   event: InngestEvent,
   events: Schema.Array(InngestEvent),
-  steps: Schema.optionalWith(Schema.Record({ key: Schema.String, value: StepResult }), { default: () => ({}) }),
+  steps: Schema.Record(Schema.String, StepResult).pipe(Schema.withDecodingDefault(Effect.succeed({}))),
   ctx: SDKRequestContext,
-  version: Schema.optionalWith(Schema.Number, { default: () => 1 }),
-  use_api: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+  version: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(1))),
+  use_api: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
 }) {}
 
 export const Headers = {
@@ -108,7 +111,7 @@ export const Headers = {
 } as const;
 
 export class GeneratorOpcode extends Schema.Class<GeneratorOpcode>("GeneratorOpcode")({
-  op: Schema.Literal(
+  op: Schema.Literals([
     Opcode.None,
     Opcode.Step,
     Opcode.StepRun,
@@ -124,10 +127,10 @@ export class GeneratorOpcode extends Schema.Class<GeneratorOpcode>("GeneratorOpc
     Opcode.StepFailed,
     Opcode.SyncRunComplete,
     Opcode.DiscoveryRequest,
-  ),
+  ]),
   id: Schema.String,
   name: Schema.String,
-  mode: Schema.optional(Schema.Literal("sync", "async")),
+  mode: Schema.optional(Schema.Literals(["sync", "async"])),
   opts: Schema.optional(WireUnknown),
   data: Schema.optional(WireUnknown),
   error: Schema.optional(UserError),
@@ -158,9 +161,17 @@ export const stepError = (info: StepInfo, error: UserError, noRetry?: boolean):
 };
 
 export const sleep = (info: StepInfo, duration: string): GeneratorOpcode =>
-  // Official SDK puts duration/timestamp in `name` field, not opts.duration
-  // mode: "async" is required per the Op type definition
-  GeneratorOpcode.make({ op: Opcode.Sleep, id: info.hash, name: duration, displayName: info.name, mode: "async" });
+  // Spec §5.3.2 requires `opts.duration`. The Inngest executor also accepts
+  // `name: duration` (de facto inngest-js behavior); we emit both so both
+  // the spec-strict path and the official-SDK-lenient path see a value.
+  GeneratorOpcode.make({
+    op: Opcode.Sleep,
+    id: info.hash,
+    name: duration,
+    displayName: info.name,
+    mode: "async",
+    opts: { duration },
+  });
 
 export const waitForEvent = (info: StepInfo, opts: { event: string; timeout: string; if?: string }): GeneratorOpcode =>
   mkOpcode(info, Opcode.WaitForEvent, { mode: "async", opts });
@@ -170,27 +181,41 @@ export const invokeFunction = (
   opts: { function_id: string; payload: unknown; timeout: string },
 ): GeneratorOpcode => mkOpcode(info, Opcode.InvokeFunction, { mode: "async", 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).
+ */
+export const runComplete = (data: unknown): GeneratorOpcode =>
+  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).
+ */
+export const discoveryRequest = (): GeneratorOpcode =>
+  GeneratorOpcode.make({ op: Opcode.DiscoveryRequest, id: "step", name: "step" });
+
 const IntrospectionBase = Schema.Struct({
   function_count: Schema.Number,
   has_event_key: Schema.Boolean,
   has_signing_key: Schema.Boolean,
   has_signing_key_fallback: Schema.Boolean,
-  mode: Schema.Literal("cloud", "dev"),
+  mode: Schema.Literals(["cloud", "dev"]),
   schema_version: Schema.Literal("2024-05-24"),
-  extra: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+  extra: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 });
 
-export const IntrospectionUnauthenticated = Schema.extend(
-  IntrospectionBase,
-  Schema.Struct({
-    authentication_succeeded: Schema.Union(Schema.Literal(false), Schema.Null),
-    functions: Schema.optionalWith(Schema.Array(Schema.Unknown), { exact: true }),
+export const IntrospectionUnauthenticated = IntrospectionBase.pipe(
+  Schema.fieldsAssign({
+    authentication_succeeded: Schema.Union([Schema.Literal(false), Schema.Null]),
+    functions: Schema.optionalKey(Schema.Array(Schema.Unknown)),
   }),
 );
 
-export const IntrospectionAuthenticated = Schema.extend(
-  IntrospectionBase,
-  Schema.Struct({
+export const IntrospectionAuthenticated = IntrospectionBase.pipe(
+  Schema.fieldsAssign({
     authentication_succeeded: Schema.Literal(true),
     api_origin: Schema.String,
     app_id: Schema.String,
@@ -207,8 +232,27 @@ export const IntrospectionAuthenticated = Schema.extend(
   }),
 );
 
-export const IntrospectionResponse = Schema.Union(IntrospectionAuthenticated, IntrospectionUnauthenticated);
+export const IntrospectionResponse = Schema.Union([IntrospectionAuthenticated, IntrospectionUnauthenticated]);
 
+/**
+ * SDK → executor response shape for PUT sync requests per spec §4.3.1.
+ */
 export const RegisterResponse = Schema.Struct({
-  message: Schema.optional(Schema.String),
+  message: Schema.String,
+  modified: Schema.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.
+ */
+export const RegisterServerResponse = Schema.Union([
+  Schema.Struct({
+    ok: Schema.Literal(true),
+    modified: Schema.optional(Schema.Boolean),
+  }),
+  Schema.Struct({
+    error: Schema.optional(Schema.String),
+  }),
+]);

package/src/internal/signature.ts

@@ -8,13 +8,14 @@ import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 import * as Protocol from "./protocol.js";
 
 /**
  * @internal
  */
-export class SignatureError extends Schema.TaggedError<SignatureError>()("SignatureError", {
-  reason: Schema.Literal("missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"),
+export class SignatureError extends Schema.TaggedErrorClass<SignatureError>()("SignatureError", {
+  reason: Schema.Literals(["missing_header", "invalid_format", "expired", "invalid_signature", "missing_signing_key"]),
   message: Schema.String,
 }) {}
 
@@ -40,20 +41,23 @@ export interface SignatureService {
 /**
  * @internal
  */
-export class Signature extends Context.Tag("effect-inngest/Signature")<Signature, SignatureService>() {}
+export class Signature extends Context.Service<Signature, SignatureService>()("effect-inngest/Signature") {}
 
 // ─────────────────────────────────────────────────────────────
 // Schemas (internal)
 // ─────────────────────────────────────────────────────────────
 
-const TimestampSeconds = Schema.NumberFromString.pipe(Schema.int(), Schema.positive());
+const TimestampSeconds = Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThan(0)));
 // Case-insensitive hex, normalized to lowercase in parseSignatureHeader
 const SignatureHex = Schema.String.pipe(
-  Schema.pattern(/^[a-fA-F0-9]{64}$/),
-  Schema.transform(Schema.String, {
-    decode: (s) => s.toLowerCase(),
-    encode: (s) => s,
-  }),
+  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 });
 
@@ -66,7 +70,7 @@ const SIGNATURE_VALIDITY_WINDOW_MS = 5 * 60 * 1000;
 const parseSignatureHeader = (header: string) => {
   const params = new URLSearchParams(header);
   const raw = { t: params.get("t") ?? "", s: params.get("s") ?? "" };
-  return Schema.decodeUnknown(SignatureParams)(raw).pipe(
+  return Schema.decodeUnknownEffect(SignatureParams)(raw).pipe(
     Effect.mapError(
       () =>
         new SignatureError({
@@ -82,6 +86,18 @@ const extractKeyBytes = (signingKey: string): Buffer => {
   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
+ */
+export const hashSigningKey = (signingKey: string): string => {
+  const keyWithoutPrefix = signingKey.replace(/^signkey-\w+-/, "");
+  return Crypto.createHash("sha256").update(keyWithoutPrefix).digest("hex");
+};
+
 const computeSignature = (keyBytes: Buffer, body: Uint8Array, timestamp: string): string =>
   Crypto.createHmac("sha256", keyBytes).update(body).update(timestamp).digest("hex");
 
@@ -107,52 +123,54 @@ const checkSignature = (signature: string, body: Uint8Array, timestamp: string,
 /**
  * @internal
  */
-export const SignatureLive: Layer.Layer<Signature> = 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 ${Protocol.Headers.Signature} header`,
-          });
-        }
-
-        const { t: timestampSeconds, s: signature } = yield* parseSignatureHeader(signatureHeader);
-        const timestampMs = timestampSeconds * 1000;
-        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);
-        const keys = [signingKey, signingKeyFallback].filter(Boolean) as string[];
-        const valid = keys.some((key) => checkSignature(signature, body, timestamp, key));
-
-        if (valid) 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 / 1000);
-          return `t=${ts}&s=${computeSignature(extractKeyBytes(signingKey), body, String(ts))}`;
-        }),
-      ),
+export const SignatureLive: Layer.Layer<Signature> = Layer.succeed(Signature, {
+  verify: Effect.fn("Signature.verify")(function* ({
+    body,
+    signatureHeader,
+    signingKey,
+    signingKeyFallback,
+    isDev,
+  }: VerifyOptions) {
+    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 ${Protocol.Headers.Signature} header`,
+      });
+    }
+
+    const { t: timestampSeconds, s: signature } = yield* parseSignatureHeader(signatureHeader);
+    const timestampMs = timestampSeconds * 1000;
+    const now = yield* DateTime.now;
+
+    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`,
+      });
+    }
+
+    const timestamp = String(timestampSeconds);
+    const keys = [signingKey, signingKeyFallback].filter(Boolean) as string[];
+    const valid = keys.some((key) => checkSignature(signature, body, timestamp, key));
+
+    if (valid) 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.epochMilliseconds / 1000);
+        return `t=${ts}&s=${computeSignature(extractKeyBytes(signingKey), body, String(ts))}`;
+      }),
+    ),
+});

package/src/internal/step.ts

@@ -3,7 +3,6 @@
  * @internal
  */
 import * as Arr from "effect/Array";
-import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as HashMap from "effect/HashMap";
@@ -15,6 +14,7 @@ import * as Schema from "effect/Schema";
 import { pipe } from "effect/Function";
 import { InngestClient } from "../Client.js";
 import type { InngestFunction } from "../Function.js";
+import type { CheckpointState } from "./checkpoint.js";
 import * as Protocol from "./protocol.js";
 import { StepError, SendEventError, isNonRetriableError, isRetryAfterError } from "./errors.js";
 import { timeStr, formatTimestamp } from "./helpers.js";
@@ -68,7 +68,7 @@ interface StepOptions {
 type StepOptionsOrId = string | StepOptions;
 
 interface WaitForEventOptions {
-  readonly timeout: Duration.DurationInput;
+  readonly timeout: Duration.Input;
   readonly if?: string;
 }
 
@@ -76,20 +76,22 @@ 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 };
 
-const encodeTaggedEvent = (event: TaggedEvent): Effect.Effect<unknown, never> => {
+const encodeTaggedEvent = (event: TaggedEvent): Effect.Effect<unknown, never, 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 Schema.encodeEffect(ctor as unknown as Schema.Top)(event).pipe(
+      Effect.orElseSucceed(() => event),
+    ) as Effect.Effect<unknown, never, never>;
   }
   return Effect.succeed(event);
 };
@@ -99,7 +101,7 @@ interface StepTools {
     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,
@@ -128,8 +130,6 @@ export interface HandlerContext<F extends InngestFunction.Any> {
   readonly run: RunContext;
 }
 
-export class Step extends Context.Tag("effect-inngest/Step")<Step, StepTools>() {}
-
 const normalizeOpts = (opts: StepOptionsOrId): { id: string; name: string } =>
   typeof opts === "string" ? { id: opts, name: opts } : { id: opts.id, name: opts.name ?? opts.id };
 
@@ -140,6 +140,7 @@ export const createStepTools = (
   request: Protocol.SDKRequestBody,
   appName: string,
   stepIdCounts: Ref.Ref<HashMap.HashMap<string, number>>,
+  checkpoint: Option.Option<CheckpointState> = Option.none(),
 ): StepTools => {
   const ctx = request.ctx;
   const steps = request.steps as Record<string, unknown>;
@@ -159,7 +160,15 @@ export const createStepTools = (
   const canExecute = (hash: string) => ctx.step_id === hash || ctx.step_id === "step";
   const isBlocked = (hash: string) => ctx.disable_immediate_execution && ctx.step_id !== hash;
 
-  const sleep = (opts: StepOptionsOrId, duration: Duration.DurationInput): Effect.Effect<void, StepInterrupt> =>
+  // In checkpoint mode, async opcodes (sleep/wait/invoke) MUST flush the
+  // buffer before yielding so the executor sees buffered StepRuns prepended
+  // to the async opcode in the 206 response (spec §10.2 / §10.4.1 #6).
+  const flushIfCheckpoint = Option.match(checkpoint, {
+    onNone: () => Effect.void,
+    onSome: (state) => state.flush,
+  });
+
+  const sleep = (opts: StepOptionsOrId, duration: Duration.Input): Effect.Effect<void, StepInterrupt> =>
     Effect.flatMap(getInfo(opts), (info) =>
       pipe(
         getMemo(info.hash),
@@ -168,7 +177,13 @@ export const createStepTools = (
         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.tag("MemoNone", () =>
+          Effect.andThen(flushIfCheckpoint, Effect.fail(sleepInterrupt({ info, duration: timeStr(duration) }))).pipe(
+            Effect.withSpan(`inngest.step/sleep/${info.id}`, {
+              attributes: { [OtelAttributes.StepId]: info.id, [OtelAttributes.StepType]: "sleep" },
+            }),
+          ),
+        ),
         Match.exhaustive,
       ),
     );
@@ -182,7 +197,16 @@ export const createStepTools = (
         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.tag("MemoNone", () =>
+          Effect.andThen(
+            flushIfCheckpoint,
+            Effect.fail(sleepInterrupt({ info, duration: formatTimestamp(timestamp) })),
+          ).pipe(
+            Effect.withSpan(`inngest.step/sleepUntil/${info.id}`, {
+              attributes: { [OtelAttributes.StepId]: info.id, [OtelAttributes.StepType]: "sleepUntil" },
+            }),
+          ),
+        ),
         Match.exhaustive,
       ),
     );
@@ -210,8 +234,16 @@ export const createStepTools = (
         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 }),
+          Effect.andThen(
+            flushIfCheckpoint,
+            Effect.fail(
+              waitForEventInterrupt({
+                info,
+                event: event.identifier,
+                timeout: timeStr(options.timeout),
+                if: options.if,
+              }),
+            ),
           ),
         ),
         Match.exhaustive,
@@ -238,17 +270,20 @@ export const createStepTools = (
           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",
-              }),
+            Effect.andThen(
+              flushIfCheckpoint,
+              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",
+                }),
+              ),
             ),
           );
         }),
@@ -266,8 +301,13 @@ export const createStepTools = (
         Match.value,
         Match.tag("MemoData", ({ data }) => Effect.succeed(data as A)),
         Match.tag("MemoError", ({ error }) =>
+          // Spec §5.2.2: an uncaught memoized step error MUST be treated as
+          // non-retriable. If the user wanted to recover they would have
+          // caught the StepError at the call site; reaching the driver's
+          // top-level failure path means the error is propagating unhandled.
           stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Step failed", {
             noRetry: true,
+            cause: error,
           }),
         ),
         Match.tag("MemoTimeout", () => stepError(info.id, "Step timed out", { noRetry: true })),
@@ -285,15 +325,23 @@ export const createStepTools = (
               onFailure: (err) => {
                 const noRetry = isNonRetriableError(err) ? true : undefined;
                 const retryAfterMs = isRetryAfterError(err) ? Duration.toMillis(err.retryAfter) : undefined;
-                return Effect.zipRight(
+                return Effect.andThen(
                   Effect.annotateCurrentSpan(errorOtelAttributes(err)),
                   Effect.fail(errorInterrupt({ info, error: err, noRetry, retryAfterMs })),
                 );
               },
-              onSuccess: (data) => Effect.fail(runInterrupt({ info, data })),
+              onSuccess: (data) =>
+                Option.match(checkpoint, {
+                  // Async (non-checkpoint) mode: surface result via interrupt — driver
+                  // returns 206 with a single StepRun and yields back to executor.
+                  onNone: () => Effect.fail(runInterrupt({ info, data })),
+                  // Checkpoint mode: buffer the StepRun (best-effort flush handled by
+                  // bufferStep) and continue execution with the value (spec §10.4.1).
+                  onSome: (state) => Effect.as(state.bufferStep(Protocol.stepRun(info, data)), data as A),
+                }),
             }),
-            Effect.catchAllDefect((defect) =>
-              Effect.zipRight(
+            Effect.catchDefect((defect) =>
+              Effect.andThen(
                 Effect.annotateCurrentSpan(errorOtelAttributes(defect)),
                 Effect.fail(errorInterrupt({ info, error: defect })),
               ),
@@ -329,12 +377,17 @@ export const createStepTools = (
               Effect.map(encodeTaggedEvent(e), (encoded) => ({ name: e._tag, data: encoded })),
             ),
             (eventPayloads) =>
-              Effect.flatMap(InngestClient, (client) =>
+              InngestClient.use((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 }))),
+                  Effect.flatMap((result) =>
+                    Option.match(checkpoint, {
+                      onNone: () => Effect.fail(runInterrupt({ info, data: result })),
+                      onSome: (state) => Effect.as(state.bufferStep(Protocol.stepRun(info, result)), result),
+                    }),
+                  ),
                 ),
               ),
           );

package/dist/_virtual/rolldown_runtime.js

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