alchemy 2.0.0-beta.60 → 2.0.0-beta.62

package/src/AWS/Kinesis/StreamConsumer.ts

@@ -178,9 +178,7 @@ const adoptExistingConsumer = Effect.fn(function* (
   }).pipe(
     Effect.retry({
       while: (e) => e._tag === "ConsumerRegistryNotConsistent",
-      schedule: Schedule.exponential(250).pipe(
-        Schedule.both(Schedule.recurs(8)),
-      ),
+      schedule: Schedule.max([Schedule.exponential(250), Schedule.recurs(8)]),
     }),
     Effect.catchTag("ConsumerRegistryNotConsistent", () =>
       Effect.fail(
@@ -210,9 +208,7 @@ const waitForConsumerStatus = (
     Effect.retry({
       while: (e: { _tag: string }) =>
         e._tag === "ConsumerStatusNotReady" || e._tag === "ParseError",
-      schedule: Schedule.exponential(500).pipe(
-        Schedule.both(Schedule.recurs(60)),
-      ),
+      schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(60)]),
     }),
   );
 
@@ -226,9 +222,7 @@ const waitForConsumerDeleted = (consumerArn: string) =>
     Effect.retry({
       while: (e: { _tag: string }) =>
         e._tag === "ConsumerStillExists" || e._tag === "ParseError",
-      schedule: Schedule.exponential(500).pipe(
-        Schedule.both(Schedule.recurs(60)),
-      ),
+      schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(60)]),
     }),
     Effect.catchTag("ResourceNotFoundException", () => Effect.void),
   );
@@ -309,9 +303,10 @@ export const StreamConsumerProvider = () =>
             // propagation window before giving up.
             Effect.retry({
               while: (e) => e._tag === "ResourceNotFoundException",
-              schedule: Schedule.exponential(500).pipe(
-                Schedule.both(Schedule.recurs(8)),
-              ),
+              schedule: Schedule.max([
+                Schedule.exponential(500),
+                Schedule.recurs(8),
+              ]),
             }),
             Effect.asVoid,
             Effect.catchTag("ResourceInUseException", () =>

package/src/AWS/Lambda/Alias.ts

@@ -8,6 +8,10 @@ import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { AWSEnvironment } from "../Environment.ts";
 import type { Providers } from "../Providers.ts";
+import {
+  syncEventInvokeConfig,
+  type EventInvokeConfig,
+} from "./EventInvokeConfig.ts";
 
 export interface AliasProps {
   /**
@@ -31,6 +35,13 @@ export interface AliasProps {
    * function version.
    */
   routingConfig?: Lambda.AliasRoutingConfiguration;
+  /**
+   * Asynchronous invocation settings (retries, event age, destinations)
+   * scoped to this alias. Omit to remove any existing alias-level config and
+   * fall back to Lambda's defaults (2 retries, 6-hour max event age, no
+   * destinations).
+   */
+  eventInvokeConfig?: EventInvokeConfig;
 }
 
 export interface Alias extends Resource<
@@ -101,6 +112,24 @@ export interface Alias extends Resource<
  *   },
  * });
  * ```
+ *
+ * @section Async Invocation
+ * @example Alias-Scoped Retry Behavior
+ * ```typescript
+ * const alias = yield* Alias("LiveAlias", {
+ *   functionName: fn.functionName,
+ *   functionVersion: "2",
+ *   aliasName: "live",
+ *   eventInvokeConfig: {
+ *     maximumRetryAttempts: 0,
+ *     destinationConfig: {
+ *       OnFailure: {
+ *         Destination: queue.queueArn,
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
  */
 export const Alias = Resource<Alias>("AWS.Lambda.Alias");
 
@@ -136,9 +165,10 @@ export const AliasProvider = () =>
         effect.pipe(
           Effect.retry({
             while: (e) => e._tag === "ResourceConflictException",
-            schedule: Schedule.exponential(500).pipe(
-              Schedule.both(Schedule.recurs(10)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential(500),
+              Schedule.recurs(10),
+            ]),
           }),
         );
 
@@ -284,6 +314,12 @@ export const AliasProvider = () =>
             );
           }
 
+          yield* syncEventInvokeConfig({
+            functionName: news.functionName,
+            qualifier: attrs.aliasName,
+            config: news.eventInvokeConfig,
+          });
+
           yield* session.note(
             `Alias ${attrs.aliasName} on ${attrs.functionName}`,
           );
@@ -291,6 +327,13 @@ export const AliasProvider = () =>
           return attrs;
         }),
         delete: Effect.fn(function* ({ output }) {
+          // The alias-scoped async config does not die with the alias — clear
+          // it first so a later alias of the same name starts clean.
+          yield* syncEventInvokeConfig({
+            functionName: output.functionName,
+            qualifier: output.aliasName,
+            config: undefined,
+          });
           yield* retryOnAliasConflict(
             Lambda.deleteAlias({
               FunctionName: output.functionName,

package/src/AWS/Lambda/EventInvokeConfig.ts

@@ -0,0 +1,146 @@
+import * as Lambda from "@distilled.cloud/aws/lambda";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import { deepEqual } from "../../Diff.ts";
+
+const DEFAULT_MAXIMUM_RETRY_ATTEMPTS = 2;
+const DEFAULT_MAXIMUM_EVENT_AGE_IN_SECONDS = 21_600;
+
+/**
+ * Asynchronous invocation settings for a Lambda function or alias.
+ *
+ * Configured via {@link FunctionProps.eventInvokeConfig} for the unqualified
+ * function, or {@link AliasProps.eventInvokeConfig} for a specific alias.
+ */
+export interface EventInvokeConfig {
+  /**
+   * Maximum number of times Lambda retries an asynchronous invocation.
+   * @default 2
+   */
+  maximumRetryAttempts?: number;
+  /**
+   * Maximum age in seconds that Lambda retains an asynchronous event.
+   * @default 21600
+   */
+  maximumEventAgeInSeconds?: number;
+  /**
+   * Destinations for successful or failed asynchronous invocation records.
+   */
+  destinationConfig?: Lambda.DestinationConfig;
+}
+
+const retryOnConflict = <A, E extends { _tag: string }, R>(
+  effect: Effect.Effect<A, E, R>,
+) =>
+  effect.pipe(
+    Effect.retry({
+      while: (e) => e._tag === "ResourceConflictException",
+      schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(10)]),
+    }),
+  );
+
+const normalizeDestinationConfig = (
+  config: Lambda.DestinationConfig | undefined,
+): Lambda.DestinationConfig | undefined => {
+  const onSuccess = config?.OnSuccess?.Destination
+    ? { Destination: config.OnSuccess.Destination }
+    : undefined;
+  const onFailure = config?.OnFailure?.Destination
+    ? { Destination: config.OnFailure.Destination }
+    : undefined;
+  return onSuccess || onFailure
+    ? {
+        OnSuccess: onSuccess,
+        OnFailure: onFailure,
+      }
+    : undefined;
+};
+
+const observeConfig = (functionName: string, qualifier: string | undefined) =>
+  Lambda.getFunctionEventInvokeConfig({
+    FunctionName: functionName,
+    Qualifier: qualifier,
+  }).pipe(
+    Effect.catchTag("ResourceNotFoundException", () =>
+      Effect.succeed(undefined),
+    ),
+  );
+
+/**
+ * Converge the async invocation config of a function or alias to the desired
+ * state: put it when set, delete it when omitted. Diffs against the observed
+ * cloud config so a no-op deploy skips the write entirely.
+ */
+export const syncEventInvokeConfig = Effect.fn(function* ({
+  functionName,
+  qualifier,
+  config,
+}: {
+  functionName: string;
+  /** Alias name (or version) to scope the config to. Omit for `$LATEST`. */
+  qualifier?: string;
+  config: EventInvokeConfig | undefined;
+}) {
+  const observed = yield* observeConfig(functionName, qualifier);
+
+  if (config === undefined) {
+    if (observed) {
+      yield* retryOnConflict(
+        Lambda.deleteFunctionEventInvokeConfig({
+          FunctionName: functionName,
+          Qualifier: qualifier,
+        }),
+      ).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
+    }
+    return;
+  }
+
+  const desired = {
+    maximumRetryAttempts:
+      config.maximumRetryAttempts ?? DEFAULT_MAXIMUM_RETRY_ATTEMPTS,
+    maximumEventAgeInSeconds:
+      config.maximumEventAgeInSeconds ?? DEFAULT_MAXIMUM_EVENT_AGE_IN_SECONDS,
+    destinationConfig: normalizeDestinationConfig(config.destinationConfig),
+  };
+
+  if (
+    observed &&
+    (observed.MaximumRetryAttempts ?? DEFAULT_MAXIMUM_RETRY_ATTEMPTS) ===
+      desired.maximumRetryAttempts &&
+    (observed.MaximumEventAgeInSeconds ??
+      DEFAULT_MAXIMUM_EVENT_AGE_IN_SECONDS) ===
+      desired.maximumEventAgeInSeconds &&
+    deepEqual(
+      normalizeDestinationConfig(observed.DestinationConfig),
+      desired.destinationConfig,
+    )
+  ) {
+    return;
+  }
+
+  yield* Lambda.putFunctionEventInvokeConfig({
+    FunctionName: functionName,
+    Qualifier: qualifier,
+    MaximumRetryAttempts: desired.maximumRetryAttempts,
+    MaximumEventAgeInSeconds: desired.maximumEventAgeInSeconds,
+    DestinationConfig: desired.destinationConfig,
+  }).pipe(
+    Effect.retry({
+      while: (
+        e,
+      ): e is
+        | Lambda.ResourceConflictException
+        | Lambda.InvalidParameterValueException =>
+        e._tag === "ResourceConflictException" ||
+        // Destination validation races IAM policy propagation on the
+        // execution role — Lambda rejects the put until the role can reach
+        // the destination.
+        (e._tag === "InvalidParameterValueException" &&
+          (e.message?.includes(
+            "The function execution role does not have permissions to call",
+          ) ??
+            false)),
+      schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(10)]),
+    }),
+  );
+});

package/src/AWS/Lambda/EventSourceMapping.ts

@@ -716,9 +716,10 @@ export const EventSourceMappingProvider = () =>
                 while: (e: any) =>
                   e._tag === "ResourceInUseException" ||
                   e._tag === "ResourceConflictException",
-                schedule: Schedule.exponential(100).pipe(
-                  Schedule.both(Schedule.recurs(20)),
-                ),
+                schedule: Schedule.max([
+                  Schedule.exponential(100),
+                  Schedule.recurs(20),
+                ]),
               }),
               retryPermissionsPropagation,
               retryTransient,
@@ -762,9 +763,10 @@ export const EventSourceMappingProvider = () =>
               while: (e: any) =>
                 e._tag === "ResourceInUseException" ||
                 e._tag === "ResourceConflictException",
-              schedule: Schedule.exponential(100).pipe(
-                Schedule.both(Schedule.recurs(20)),
-              ),
+              schedule: Schedule.max([
+                Schedule.exponential(100),
+                Schedule.recurs(20),
+              ]),
             }),
             Effect.catchTag("ResourceNotFoundException", () => Effect.void),
           );
@@ -818,7 +820,7 @@ const retryTransient: <A, R, Err>(
     e._tag === "TooManyRequestsException" ||
     e._tag === "RequestLimitExceeded" ||
     e._tag === "ResourceInUseException",
-  schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(30))),
+  schedule: Schedule.max([Schedule.exponential(100), Schedule.recurs(30)]),
 });
 
 const retryPermissionsPropagation = Effect.retry({
@@ -831,7 +833,7 @@ const retryPermissionsPropagation = Effect.retry({
       e.message?.includes("Please add Lambda as a Trusted Entity") ||
       e.message?.includes("Cannot access stream") ||
       e.message?.includes("Please ensure the role can perform the GetRecords")),
-  schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(30))),
+  schedule: Schedule.max([Schedule.exponential(100), Schedule.recurs(30)]),
 }) as <A, R, Err>(self: Effect.Effect<A, Err, R>) => Effect.Effect<A, Err, R>;
 
 const sanitizeAwsTagValue = (value: string) =>

package/src/AWS/Lambda/Function.ts

@@ -5,13 +5,17 @@ import type { CreateFunctionRequest } from "@distilled.cloud/aws/lambda";
 import * as Lambda from "@distilled.cloud/aws/lambda";
 import { Region } from "@distilled.cloud/aws/Region";
 import type * as lambda from "aws-lambda";
+import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
+import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type * as rolldown from "rolldown";
@@ -27,7 +31,7 @@ import {
 } from "../../Bundle/InstalledPackages.ts";
 import * as TempRoot from "../../Bundle/TempRoot.ts";
 import { deepEqual, isResolved } from "../../Diff.ts";
-import type { HttpEffect } from "../../Http.ts";
+import { isScopeEjected, type HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
@@ -51,6 +55,10 @@ import { AWSEnvironment } from "../Environment.ts";
 import * as IAM from "../IAM/index.ts";
 import type { PolicyStatement } from "../IAM/Policy.ts";
 import type { Providers } from "../Providers.ts";
+import {
+  syncEventInvokeConfig,
+  type EventInvokeConfig,
+} from "./EventInvokeConfig.ts";
 import { makeFunctionHttpHandler } from "./HttpServer.ts";
 
 export const FunctionTypeId = "AWS.Lambda.Function" as const;
@@ -159,6 +167,14 @@ export interface FunctionProps extends PlatformProps {
    * Omit to remove the function-level reserved concurrency limit.
    */
   reservedConcurrentExecutions?: number;
+  /**
+   * Asynchronous invocation settings (retries, event age, destinations) for
+   * the unqualified function. Omit to remove any existing config and fall
+   * back to Lambda's defaults (2 retries, 6-hour max event age, no
+   * destinations). Use {@link AliasProps.eventInvokeConfig} to scope the
+   * config to an alias instead.
+   */
+  eventInvokeConfig?: EventInvokeConfig;
 }
 
 /**
@@ -275,10 +291,24 @@ const matchesConfiguredExternal = (
  * - **Async** — plain handler export, no Effect runtime in the bundle.
  * - **Effect** — Effect implementation with typed bindings and event sources.
  *
- * See the {@link https://alchemy.run/guides/async-lambda | Async Lambda Guide}
+ * See [Effect handlers vs async handlers](/infrastructure-as-effects/functions-and-servers#effect-handlers-vs-async-handlers)
  * for plain handler patterns, or the
- * {@link https://alchemy.run/guides/lambda | Effect Lambda Guide}
+ * [Lambda guide](/aws/compute/lambda)
  * for the full Effect-based approach with bindings, event sources, and sinks.
+ *
+ * :::caution[Request finalizers block the response — there is no `waitUntil` on Lambda]
+ * `Effect.addFinalizer` in a handler runs **before the response is
+ * returned**: a buffered invocation's response is not released until the
+ * Invoke phase completes, and no deferral scheme is reliable (dangling
+ * promises are dropped on crash/timeout resets and their sockets rarely
+ * survive the freeze — silent data loss). Keep request finalizers cheap
+ * (closing a pool is milliseconds), and write anything that must not be
+ * lost durably — a queue, a table — inside the handler itself. Init-level
+ * finalizers instead run in the 500 ms `SIGTERM` window at sandbox
+ * shutdown, which the generated entry obtains by registering an internal
+ * extension. See
+ * [Sandbox scope vs invocation scope](/aws/compute/lambda#sandbox-scope-vs-invocation-scope).
+ * :::
  * @resource
  * @section Async Functions
  * Point `main` at a file that exports a standard Lambda handler. No
@@ -384,6 +414,22 @@ const matchesConfiguredExternal = (
  * });
  * ```
  *
+ * @example Async invocation retries and failure destination
+ * ```typescript
+ * const func = yield* AWS.Lambda.Function("AsyncFunction", {
+ *   main: "./src/handler.ts",
+ *   eventInvokeConfig: {
+ *     maximumRetryAttempts: 0,
+ *     maximumEventAgeInSeconds: 60,
+ *     destinationConfig: {
+ *       OnFailure: {
+ *         Destination: queue.queueArn,
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ *
  * @section S3 Bindings
  * Bind S3 operations in the init phase to give the function IAM
  * permissions and inject the bucket name as an environment variable.
@@ -613,11 +659,39 @@ export const Function: Platform<
               for (const handler of handlers) {
                 const eff = handler(event);
                 if (Effect.isEffect(eff)) {
-                  return await eff.pipe(
-                    Effect.provideService(HandlerContext, context),
+                  // Each invocation gets a fresh request scope, matching the
+                  // Worker / Durable Object / Workflow bridges. The scope is
+                  // settled inline before returning: a buffered Lambda
+                  // response is not released to the caller until the Invoke
+                  // phase completes, so deferring cleanup (e.g. via an
+                  // INVOKE-subscribed extension window) shows up as response
+                  // latency anyway — keep request finalizers fast. A failing
+                  // finalizer is logged and ignored so it can't mask the
+                  // invocation's outcome.
+                  const scope = Scope.makeUnsafe();
+                  const exit = await eff.pipe(
+                    Effect.provide(
+                      Layer.mergeAll(
+                        Layer.succeed(HandlerContext, context),
+                        Layer.succeed(Scope.Scope, scope),
+                      ),
+                    ),
                     Effect.tap(Effect.logDebug),
-                    Effect.runPromise,
+                    Effect.runPromiseExit,
                   );
+                  if (!isScopeEjected(scope)) {
+                    await Scope.close(scope, exit).pipe(
+                      Effect.ignoreCause({
+                        log: "Warn",
+                        message: "Lambda invocation scope close failed",
+                      }),
+                      Effect.runPromise,
+                    );
+                  }
+                  if (Exit.isSuccess(exit)) {
+                    return exit.value;
+                  }
+                  throw Cause.squash(exit.cause);
                 }
               }
               throw new Error("No event handler found");
@@ -867,19 +941,33 @@ export const FunctionProvider = () =>
 import { layer as nodeServicesLayer } from "@effect/platform-node/NodeServices";
 import { Stack } from "alchemy/Stack";
 import { makeEntrypointLayer } from "alchemy/Runtime";
+import { registerLambdaExtension } from "alchemy/AWS/Lambda/RuntimeExtension";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Credentials from "@distilled.cloud/aws/Credentials";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import { layer as fetchHttpClientLayer } from "effect/unstable/http/FetchHttpClient";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as Region from "@distilled.cloud/aws/Region";
 import * as Context from "effect/Context";
+import * as Scope from "effect/Scope";
 import { MinimumLogLevel } from "effect/References";
 
 import entrypoint from ${JSON.stringify(importPath)};
 
+// Register the internal extension: it buys the Shutdown phase (SIGTERM +
+// 500 ms) — without any registered extension the sandbox is killed with no
+// signal at all, and init-level finalizers would never run.
+await registerLambdaExtension();
+
+// Instance scope: the sandbox-lifetime layer build lives under it, and it is
+// closed on SIGTERM (Lambda's Shutdown phase) so init-level finalizers run
+// before the sandbox dies. Each invocation still gets its own request scope
+// from the handler dispatch.
+const instanceScope = Scope.makeUnsafe();
+
 const tag = Context.Service("${Self.key}")
 const layer = makeEntrypointLayer(tag, entrypoint);
 
@@ -905,33 +993,52 @@ const stack = Layer.effect(
   )
 );
 
-const handlerEffect = tag.pipe(
-  Effect.flatMap(func => func.RuntimeContext.exports),
-  Effect.flatMap(exports => exports.handler),
-  Effect.provide(
-    layer.pipe(
-      Layer.provideMerge(stack),
-      Layer.provideMerge(Credentials.fromEnv()),
-      Layer.provideMerge(Region.fromEnv()),
-      Layer.provideMerge(platform),
-      Layer.provideMerge(
-        Layer.succeed(
-          ConfigProvider.ConfigProvider,
-          ConfigProvider.fromEnv()
-        )
-      ),
-      Layer.provideMerge(
-        Layer.succeed(
-          MinimumLogLevel,
-          process.env.DEBUG ? "Debug" : "Info",
-        )
-      ),
+const entryLayer = layer.pipe(
+  Layer.provideMerge(stack),
+  Layer.provideMerge(Credentials.fromEnv()),
+  Layer.provideMerge(Region.fromEnv()),
+  Layer.provideMerge(platform),
+  Layer.provideMerge(
+    Layer.succeed(
+      ConfigProvider.ConfigProvider,
+      ConfigProvider.fromEnv()
+    )
+  ),
+  Layer.provideMerge(
+    Layer.succeed(
+      MinimumLogLevel,
+      process.env.DEBUG ? "Debug" : "Info",
+    )
+  ),
+);
+
+// Build the layer stack against the instance scope (not a transient
+// \`Effect.provide\`/\`Effect.scoped\` region) so services and init-level
+// finalizers live for the sandbox and are released at Shutdown.
+const handlerEffect = Layer.buildWithScope(entryLayer, instanceScope).pipe(
+  Effect.flatMap((context) =>
+    tag.pipe(
+      Effect.flatMap(func => func.RuntimeContext.exports),
+      Effect.flatMap(exports => exports.handler),
+      Effect.provideContext(context),
     )
   ),
-  Effect.scoped
+  Scope.provide(instanceScope),
 );
 
-export default await Effect.runPromise(handlerEffect)
+const handler = await Effect.runPromise(handlerEffect);
+
+// Lambda's Shutdown phase: close the instance scope so init-level
+// finalizers run, then exit inside the 500 ms budget. SIGKILL follows if we
+// overstay, so finalizers must be fast and best-effort.
+process.on("SIGTERM", () => {
+  console.log("[alchemy] SIGTERM — closing instance scope");
+  Effect.runPromise(Scope.close(instanceScope, Exit.void))
+    .catch((error) => console.error("[alchemy] shutdown finalizers failed", error))
+    .finally(() => process.exit(0));
+});
+
+export default handler;
 `,
               ),
             );
@@ -1029,9 +1136,10 @@ export default await Effect.runPromise(handlerEffect)
         while: (e: any) =>
           e._tag === "ResourceConflictException" ||
           e._tag === "TooManyRequestsException",
-        schedule: Schedule.exponential(100).pipe(
-          Schedule.both(Schedule.recurs(30)),
-        ),
+        schedule: Schedule.max([
+          Schedule.exponential(100),
+          Schedule.recurs(30),
+        ]),
       }) as <A, R, Err>(
         self: Effect.Effect<A, Err, R>,
       ) => Effect.Effect<A, Err, R>;
@@ -1267,7 +1375,7 @@ export default await Effect.runPromise(handlerEffect)
           Effect.retry({
             while: (e) => isRolePropagationError(e),
             schedule: Schedule.fixed(1000).pipe(
-              Schedule.tapOutput(() => noteRolePropagationWait()),
+              Schedule.tap(() => noteRolePropagationWait()),
             ),
           }),
           Effect.catchTags({
@@ -1667,6 +1775,11 @@ export default await Effect.runPromise(handlerEffect)
               reservedConcurrentExecutions: news.reservedConcurrentExecutions,
             });
 
+          yield* syncEventInvokeConfig({
+            functionName,
+            config: news.eventInvokeConfig,
+          });
+
           const functionUrl = yield* createOrUpdateFunctionUrl({
             functionName,
             url: news.url,

package/src/AWS/Lambda/MicrovmProvider.ts

@@ -413,9 +413,10 @@ export const MicrovmImageProvider = () =>
             while: (e): e is ValidationException =>
               e._tag === "ValidationException" &&
               e.message.includes("running MicroVMs"),
-            schedule: Schedule.fixed(5_000).pipe(
-              Schedule.both(Schedule.recurs(12)),
-            ),
+            schedule: Schedule.max([
+              Schedule.fixed(5_000),
+              Schedule.recurs(12),
+            ]),
           }),
         );
       yield* waitForDeleted(output.imageArn, session);
@@ -489,9 +490,8 @@ const terminateRunningMicrovms = Effect.fn(function* (
     ),
     Effect.retry({
       while: (e) => e._tag === "MicrovmsActive",
-      schedule: Schedule.fixed(5_000).pipe(
-        Schedule.both(Schedule.recurs(24)),
-        Schedule.tapOutput(() =>
+      schedule: Schedule.max([Schedule.fixed(5_000), Schedule.recurs(24)]).pipe(
+        Schedule.tap(() =>
           session.note("Waiting for MicroVMs to terminate..."),
         ),
       ),
@@ -557,12 +557,12 @@ const waitForReady = (imageArn: string, session: ScopedPlanStatusSession) =>
   }).pipe(
     Effect.retry({
       while: (e) => e._tag === "ImageBuilding",
-      schedule: Schedule.fixed(10_000).pipe(
-        Schedule.both(Schedule.recurs(72)), // up to ~12 minutes
-        Schedule.tapOutput(([, attempt]) =>
-          session.note(
-            `Waiting for MicroVM image build... (${(attempt + 1) * 10}s)`,
-          ),
+      schedule: Schedule.max([
+        Schedule.fixed(10_000),
+        Schedule.recurs(72),
+      ]).pipe(
+        Schedule.tap(({ attempt }) =>
+          session.note(`Waiting for MicroVM image build... (${attempt * 10}s)`),
         ),
       ),
     }),
@@ -585,11 +585,13 @@ const waitForDeleted = (imageArn: string, session: ScopedPlanStatusSession) =>
   }).pipe(
     Effect.retry({
       while: (e) => e._tag === "ImageBuilding",
-      schedule: Schedule.fixed(10_000).pipe(
-        Schedule.both(Schedule.recurs(72)),
-        Schedule.tapOutput(([, attempt]) =>
+      schedule: Schedule.max([
+        Schedule.fixed(10_000),
+        Schedule.recurs(72),
+      ]).pipe(
+        Schedule.tap(({ attempt }) =>
           session.note(
-            `Waiting for MicroVM image deletion... (${(attempt + 1) * 10}s)`,
+            `Waiting for MicroVM image deletion... (${attempt * 10}s)`,
           ),
         ),
       ),