alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/src/Cloudflare/Email/EmailRule.ts

@@ -0,0 +1,210 @@
+import * as emailRouting from "@distilled.cloud/cloudflare/email-routing";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+import { resolveZoneId, type ZoneReference } from "../Zone.ts";
+
+export type EmailMatcher =
+  | { type: "all" }
+  | { type: "literal"; field: "to"; value: string };
+
+export type EmailAction =
+  | { type: "drop" }
+  | { type: "forward"; value: string[] }
+  | { type: "worker"; value: string[] };
+
+export type EmailRuleProps = {
+  /**
+   * Zone the rule lives on.
+   */
+  zone: ZoneReference;
+  /**
+   * Display name for the rule.
+   */
+  name?: string;
+  /**
+   * Whether the rule is active. Disabled rules are evaluated last and
+   * effectively skipped.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Lower priority numbers run first.
+   *
+   * @default 0
+   */
+  priority?: number;
+  /**
+   * Matchers that define which inbound emails trigger this rule.
+   */
+  matchers: EmailMatcher[];
+  /**
+   * Actions to take for matched emails.
+   */
+  actions: EmailAction[];
+};
+
+export type EmailRule = Resource<
+  "Cloudflare.EmailRule",
+  EmailRuleProps,
+  {
+    ruleId: string;
+    zoneId: string;
+    name: string;
+    enabled: boolean;
+    priority: number;
+    matchers: EmailMatcher[];
+    actions: EmailAction[];
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A Cloudflare Email Routing rule.
+ *
+ * Rules forward inbound mail matching `matchers` to the listed actions
+ * (forward to a verified destination, drop, or hand off to a Worker).
+ *
+ * @section Forwarding Mail
+ * @example Forward `info@` to a verified destination
+ * ```typescript
+ * const rule = yield* Cloudflare.EmailRule("InfoForward", {
+ *   zone: "example.com",
+ *   matchers: [{ type: "literal", field: "to", value: "info@example.com" }],
+ *   actions: [{ type: "forward", value: ["ops@example.com"] }],
+ * });
+ * ```
+ */
+export const EmailRule = Resource<EmailRule>("Cloudflare.EmailRule");
+
+const normalize = (
+  rule: {
+    id?: string | null;
+    name?: string | null;
+    enabled?: boolean | null;
+    priority?: number | null;
+    matchers?:
+      | {
+          type: "all" | "literal";
+          field?: "to" | null;
+          value?: string | null;
+        }[]
+      | null;
+    actions?:
+      | { type: "drop" | "forward" | "worker"; value?: string[] | null }[]
+      | null;
+  },
+  zoneId: string,
+) => ({
+  ruleId: rule.id ?? "",
+  zoneId,
+  name: rule.name ?? "",
+  enabled: rule.enabled ?? true,
+  priority: rule.priority ?? 0,
+  matchers: (rule.matchers ?? []).map(
+    (m): EmailMatcher =>
+      m.type === "all"
+        ? { type: "all" }
+        : { type: "literal", field: "to", value: m.value ?? "" },
+  ),
+  actions: (rule.actions ?? []).map(
+    (a): EmailAction =>
+      a.type === "drop"
+        ? { type: "drop" }
+        : a.type === "forward"
+          ? { type: "forward", value: a.value ?? [] }
+          : { type: "worker", value: a.value ?? [] },
+  ),
+});
+
+export const EmailRuleProvider = () =>
+  Provider.effect(
+    EmailRule,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const create = yield* emailRouting.createRule;
+      const update = yield* emailRouting.updateRule;
+      const get = yield* emailRouting.getRule;
+      const del = yield* emailRouting.deleteRule;
+
+      const resolve = (zone: ZoneReference) =>
+        resolveZoneId({
+          accountId,
+          zone,
+          hostname: typeof zone === "string" ? zone : (zone.name ?? ""),
+        });
+
+      return {
+        stables: ["ruleId", "zoneId"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!output) return undefined;
+          if (!isResolved(news)) return undefined;
+          const zoneId = yield* resolve(news.zone);
+          if (zoneId !== output.zoneId) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.ruleId || !output?.zoneId) return undefined;
+          return yield* get({
+            zoneId: output.zoneId,
+            ruleIdentifier: output.ruleId,
+          }).pipe(
+            Effect.map((r) => normalize(r, output.zoneId)),
+            Effect.catch(() => Effect.succeed(undefined)),
+          );
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const zoneId = output?.zoneId ?? (yield* resolve(news.zone));
+          const body = {
+            actions: news.actions.map((a) =>
+              a.type === "drop"
+                ? { type: a.type }
+                : { type: a.type, value: a.value },
+            ),
+            matchers: news.matchers.map((m) =>
+              m.type === "all"
+                ? { type: "all" as const }
+                : {
+                    type: "literal" as const,
+                    field: "to" as const,
+                    value: m.value,
+                  },
+            ),
+            enabled: news.enabled ?? true,
+            name: news.name ?? "",
+            priority: news.priority ?? 0,
+          };
+
+          if (output?.ruleId) {
+            const result = yield* update({
+              zoneId,
+              ruleIdentifier: output.ruleId,
+              ...body,
+            }).pipe(
+              Effect.catch(() =>
+                create({ zoneId, ...body }).pipe(Effect.map((r) => r)),
+              ),
+            );
+            return normalize(result, zoneId);
+          }
+
+          const result = yield* create({ zoneId, ...body });
+          return normalize(result, zoneId);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          if (!output?.ruleId) return;
+          yield* del({
+            zoneId: output.zoneId,
+            ruleIdentifier: output.ruleId,
+          }).pipe(Effect.catch(() => Effect.void));
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/Email/SendEmail.ts

@@ -0,0 +1,95 @@
+import * as Effect from "effect/Effect";
+import { SendEmailBinding } from "./SendEmailBinding.ts";
+
+type SendEmailTypeId = typeof SendEmailTypeId;
+const SendEmailTypeId = "Cloudflare.SendEmail" as const;
+
+export type SendEmailProps = {
+  /**
+   * Restrict the Worker to send to a single verified destination address.
+   *
+   * Mutually exclusive with `allowedDestinationAddresses`. The destination
+   * must be a verified address on the account (see {@link EmailAddress}).
+   */
+  destinationAddress?: string;
+  /**
+   * Restrict the Worker to send to one of these verified destination addresses.
+   *
+   * Mutually exclusive with `destinationAddress`.
+   */
+  allowedDestinationAddresses?: string[];
+  /**
+   * Restrict the Worker to send from one of these sender addresses.
+   *
+   * The sender domain must have Email Routing configured (see
+   * {@link EmailRouting}) and the addresses must be verified.
+   */
+  allowedSenderAddresses?: string[];
+};
+
+/**
+ * A Cloudflare Workers `send_email` binding descriptor.
+ *
+ * `SendEmail` is a Worker-only binding — it does not create any cloud-side
+ * resource. The descriptor names the binding and records optional
+ * destination/sender restrictions; the actual `send_email` entry is attached
+ * to the Worker via {@link SendEmailBinding}.
+ *
+ * @resource
+ *
+ * @section Binding to a Worker
+ * @example Send to any verified destination
+ * ```typescript
+ * const Email = Cloudflare.SendEmail("Email");
+ *
+ * // in the Worker effect:
+ * const email = yield* Cloudflare.SendEmail.bind(Email);
+ * yield* email.send({
+ *   from: "noreply@example.com",
+ *   to: "user@example.com",
+ *   subject: "Hello",
+ *   text: "Hi from Alchemy",
+ * });
+ * ```
+ *
+ * @example Restrict the sender address
+ * ```typescript
+ * const Ops = Cloudflare.SendEmail("OpsEmail", {
+ *   allowedSenderAddresses: ["noreply@example.com"],
+ *   destinationAddress: "ops@example.com",
+ * });
+ * ```
+ */
+export type SendEmail = SendEmailProps & {
+  kind: SendEmailTypeId;
+  name: string;
+};
+
+export const isSendEmail = (value: unknown): value is SendEmail =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as SendEmail).kind === SendEmailTypeId;
+
+export const SendEmail: {
+  (id: string, props?: SendEmailProps): Effect.Effect<SendEmail>;
+  /**
+   * Bind this `send_email` descriptor to the surrounding Worker. Returns a
+   * typed runtime client for sending email.
+   */
+  bind: typeof SendEmailBinding.bind;
+} = Object.assign(
+  Effect.fnUntraced(function* (id: string, props?: SendEmailProps) {
+    return {
+      kind: SendEmailTypeId,
+      name: id,
+      destinationAddress: props?.destinationAddress,
+      allowedDestinationAddresses: props?.allowedDestinationAddresses,
+      allowedSenderAddresses: props?.allowedSenderAddresses,
+    } satisfies SendEmail;
+  }),
+  {
+    bind: (...args: Parameters<typeof SendEmailBinding.bind>) =>
+      SendEmailBinding.bind(...args),
+  },
+);

package/src/Cloudflare/Email/SendEmailBinding.ts

@@ -0,0 +1,124 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { SendEmail } from "./SendEmail.ts";
+
+/**
+ * Email body shape for the builder-form `send` call. Either `text`, `html`,
+ * or both must be provided.
+ */
+export interface SendEmailMessage {
+  from: string | runtime.EmailAddress;
+  to: string | string[];
+  subject: string;
+  replyTo?: string | runtime.EmailAddress;
+  cc?: string | string[];
+  bcc?: string | string[];
+  headers?: Record<string, string>;
+  text?: string;
+  html?: string;
+  attachments?: runtime.EmailAttachment[];
+}
+
+export class SendEmailError extends Data.TaggedError("SendEmailError")<{
+  message: string;
+  cause?: unknown;
+}> {}
+
+export interface SendEmailClient {
+  /**
+   * The raw runtime `SendEmail` binding. Use this when you need direct
+   * access to the Cloudflare object (e.g. to send a pre-built
+   * `EmailMessage` from `cloudflare:email`).
+   */
+  raw: Effect.Effect<runtime.SendEmail, never, WorkerEnvironment>;
+  /**
+   * Send an email using the builder form. Equivalent to calling
+   * `env.<name>.send({ from, to, subject, text, html, ... })`.
+   */
+  send(
+    message: SendEmailMessage,
+  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, WorkerEnvironment>;
+  /**
+   * Send a raw `EmailMessage` (constructed via `cloudflare:email`).
+   */
+  sendRaw(
+    message: runtime.EmailMessage,
+  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, WorkerEnvironment>;
+}
+
+/**
+ * A typed runtime accessor for a Cloudflare `send_email` Worker binding.
+ *
+ * @binding
+ */
+export class SendEmailBinding extends Binding.Service<
+  SendEmailBinding,
+  (sender: SendEmail) => Effect.Effect<SendEmailClient>
+>()("Cloudflare.SendEmail.Binding") {}
+
+export const SendEmailBindingLive = Layer.effect(
+  SendEmailBinding,
+  Effect.gen(function* () {
+    const bind = yield* SendEmailBindingPolicy;
+
+    return Effect.fnUntraced(function* (sender: SendEmail) {
+      yield* bind(sender);
+
+      const raw = WorkerEnvironment.useSync(
+        (env) => (env as Record<string, runtime.SendEmail>)[sender.name]!,
+      );
+
+      const tryPromise = <T>(
+        fn: () => Promise<T>,
+      ): Effect.Effect<T, SendEmailError> =>
+        Effect.tryPromise({
+          try: fn,
+          catch: (error: any) =>
+            new SendEmailError({
+              message: error?.message ?? "Unknown send_email error",
+              cause: error,
+            }),
+        });
+
+      return {
+        raw,
+        send: (message: SendEmailMessage) =>
+          raw.pipe(Effect.flatMap((s) => tryPromise(() => s.send(message)))),
+        sendRaw: (message: runtime.EmailMessage) =>
+          raw.pipe(Effect.flatMap((s) => tryPromise(() => s.send(message)))),
+      } satisfies SendEmailClient;
+    });
+  }),
+);
+
+export class SendEmailBindingPolicy extends Binding.Policy<
+  SendEmailBindingPolicy,
+  (sender: SendEmail) => Effect.Effect<void>
+>()("Cloudflare.SendEmail.Binding") {}
+
+export const SendEmailBindingPolicyLive = SendEmailBindingPolicy.layer.succeed(
+  Effect.fnUntraced(function* (host: ResourceLike, sender: SendEmail) {
+    if (isWorker(host)) {
+      yield* host.bind(sender.name, {
+        bindings: [
+          {
+            type: "send_email",
+            name: sender.name,
+            destinationAddress: sender.destinationAddress,
+            allowedDestinationAddresses: sender.allowedDestinationAddresses,
+            allowedSenderAddresses: sender.allowedSenderAddresses,
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`SendEmailBinding does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);

package/src/Cloudflare/Email/index.ts

@@ -0,0 +1,5 @@
+export * from "./EmailAddress.ts";
+export * from "./EmailRouting.ts";
+export * from "./EmailRule.ts";
+export * from "./SendEmail.ts";
+export * from "./SendEmailBinding.ts";

package/src/Cloudflare/Images/ImagesBinding.ts

@@ -87,7 +87,7 @@ export const ImagesBindingLive = Layer.effect(
 
     return Effect.fn(function* (images: ImagesLike) {
       yield* Policy(images);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map(
           (env) => (env as Record<string, cf.ImagesBinding>)[images.name]!,

package/src/Cloudflare/KV/KVNamespaceBinding.ts

@@ -229,7 +229,7 @@ export const KVNamespaceBindingLive = Layer.effect(
 
     return Effect.fn(function* (bucket: KVNamespace) {
       yield* bind(bucket);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map(
           (env) =>

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -169,7 +169,15 @@ function bundleOutputToWorkerModules(
 ): WorkerModule[] {
   const modules: WorkerModule[] = [];
   for (const file of bundle.files) {
-    if (file.path.endsWith(".map") || file.content instanceof Uint8Array) {
+    if (file.path.endsWith(".map")) {
+      continue;
+    }
+    if (file.content instanceof Uint8Array) {
+      modules.push({
+        name: file.path,
+        type: file.path.endsWith(".wasm") ? "Wasm" : "Data",
+        content: file.content,
+      });
       continue;
     }
     modules.push({

package/src/Cloudflare/Local/SidecarServer.ts

@@ -55,7 +55,7 @@ const services = Layer.provideMerge(
   PlatformServices,
 );
 
-RpcServer.makeRpcServer(Sidecar.asEffect(), SidecarSchema).pipe(
+RpcServer.makeRpcServer(Sidecar, SidecarSchema).pipe(
   Effect.provide(services),
   Effect.scoped,
   runMain,

package/src/Cloudflare/Providers.ts

@@ -13,6 +13,7 @@ import { ProfileLive } from "../Auth/Profile.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as Access from "./Access.ts";
 import * as AiGateway from "./AiGateway/index.ts";
+import * as AnalyticsEngine from "./AnalyticsEngine/index.ts";
 import * as ApiToken from "./ApiToken/index.ts";
 import * as Artifacts from "./Artifacts/index.ts";
 import { CloudflareAuth } from "./Auth/AuthProvider.ts";
@@ -20,6 +21,7 @@ import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
 import * as Containers from "./Container/index.ts";
 import * as Credentials from "./Credentials.ts";
 import * as D1 from "./D1/index.ts";
+import * as Email from "./Email/index.ts";
 import * as Hyperdrive from "./Hyperdrive/index.ts";
 import * as Images from "./Images/index.ts";
 import * as KV from "./KV/index.ts";
@@ -50,11 +52,16 @@ export const providers = () =>
       ApiToken.UserApiToken,
       AiGateway.AiGateway,
       AiGateway.AiGatewayBindingPolicy,
+      AnalyticsEngine.AnalyticsEngineDatasetBindingPolicy,
       Artifacts.ArtifactsBindingPolicy,
       Command,
       Containers.Container,
       D1.D1ConnectionPolicy,
       D1.D1Database,
+      Email.EmailAddress,
+      Email.EmailRouting,
+      Email.EmailRule,
+      Email.SendEmailBindingPolicy,
       Hyperdrive.Hyperdrive,
       Hyperdrive.HyperdriveBindingPolicy,
       Images.ImagesBindingPolicy,
@@ -73,6 +80,7 @@ export const providers = () =>
       VpcService.VpcService,
       Random,
       Workers.BindWorkerPolicy,
+      Workers.CronEventSourcePolicy,
       Workers.FetchPolicy,
       Workers.Worker,
       Workflows.WorkflowResource,
@@ -84,10 +92,15 @@ export const providers = () =>
         ApiToken.UserApiTokenProvider(),
         AiGateway.AiGatewayProvider(),
         AiGateway.AiGatewayBindingPolicyLive,
+        AnalyticsEngine.AnalyticsEngineDatasetBindingPolicyLive,
         Artifacts.ArtifactsBindingPolicyLive,
         Containers.ContainerProvider(),
         D1.D1ConnectionPolicyLive,
         D1.DatabaseProvider(),
+        Email.EmailAddressProvider(),
+        Email.EmailRoutingProvider(),
+        Email.EmailRuleProvider(),
+        Email.SendEmailBindingPolicyLive,
         Hyperdrive.HyperdriveBindingPolicyLive,
         Hyperdrive.HyperdriveProvider(),
         Images.ImagesBindingPolicyLive,
@@ -105,6 +118,7 @@ export const providers = () =>
         Tunnel.TunnelProvider(),
         VpcService.VpcServiceProvider(),
         Workers.BindWorkerPolicyLive,
+        Workers.CronEventSourcePolicyLive,
         Workers.FetchPolicyLive,
         Workers.WorkerProvider(),
         Workflows.WorkflowProvider(),

package/src/Cloudflare/Queue/QueueBinding.ts

@@ -71,7 +71,7 @@ export const QueueBindingLive = Layer.effect(
 
     return Effect.fn(function* (queue: Queue) {
       yield* bind(queue);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map((env) => (env as Record<string, any>)[queue.LogicalId]),
       );

package/src/Cloudflare/R2/R2Bucket.ts

@@ -1,6 +1,7 @@
 import * as r2 from "@distilled.cloud/cloudflare/r2";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
 
 import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
@@ -355,6 +356,7 @@ export const R2BucketProvider = () =>
       const patchBucket = yield* r2.patchBucket;
       const deleteBucket = yield* r2.deleteBucket;
       const getBucket = yield* r2.getBucket;
+      const deleteObjects = yield* r2.deleteObjects;
       const listBucketDomainCustoms = yield* r2.listBucketDomainCustoms;
       const createBucketDomainCustom = yield* r2.createBucketDomainCustom;
       const updateBucketDomainCustom = yield* r2.updateBucketDomainCustom;
@@ -362,6 +364,34 @@ export const R2BucketProvider = () =>
       const getBucketLifecycle = yield* r2.getBucketLifecycle;
       const putBucketLifecycle = yield* r2.putBucketLifecycle;
 
+      const emptyBucket = (
+        bucketName: string,
+        jurisdiction: R2Bucket.Jurisdiction,
+      ) =>
+        r2.listObjects
+          .items({
+            accountId,
+            bucketName,
+            cfR2Jurisdiction: jurisdiction,
+            perPage: 1000,
+          })
+          .pipe(
+            Stream.filter(
+              (o): o is typeof o & { key: string } =>
+                typeof o.key === "string" && o.key !== "",
+            ),
+            Stream.map((o) => o.key),
+            Stream.runForEachArray((chunk) =>
+              deleteObjects({
+                accountId,
+                bucketName,
+                cfR2Jurisdiction: jurisdiction,
+                body: [...chunk],
+              }),
+            ),
+            Effect.catchTag("NoSuchBucket", () => Effect.void),
+          );
+
       const createBucketName = (id: string, name: string | undefined) =>
         Effect.gen(function* () {
           if (name) return name;
@@ -683,6 +713,7 @@ export const R2BucketProvider = () =>
               Effect.catchIf(isMissingCustomDomainOrBucket, () => Effect.void),
             );
           }
+          yield* emptyBucket(output.bucketName, output.jurisdiction);
           yield* deleteBucket({
             accountId: output.accountId,
             bucketName: output.bucketName,

package/src/Cloudflare/R2/R2BucketBinding.ts

@@ -146,7 +146,7 @@ export const R2BucketBindingLive = Layer.effect(
 
     return Effect.fn(function* (bucket: R2Bucket) {
       yield* bind(bucket);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map(
           (env) => (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId],

package/src/Cloudflare/SecretsStore/SecretBinding.ts

@@ -45,7 +45,7 @@ export const SecretBindingLive = Layer.effect(
 
     return Effect.fn(function* (secret: Secret) {
       yield* bind(secret);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map(
           (env) =>

package/src/Cloudflare/StateStore/Api.ts

@@ -29,7 +29,7 @@ export const STATE_STORE_SCRIPT_NAME = "alchemy-state-store" as const;
  * compare against this constant; a mismatch (or 404) triggers a
  * forced redeploy via the bootstrap flow.
  */
-export const STATE_STORE_VERSION = 3 as const;
+export const STATE_STORE_VERSION = 4 as const;
 
 /**
  * Hard-coded OTLP/HTTP endpoints. Point at the public ingest relay
@@ -245,6 +245,39 @@ export default Worker(
               }),
             ),
         )
+        .handle("getStackOutput", ({ params }) =>
+          store
+            .getByName(params.stack)
+            .getOutput({ stage: params.stage })
+            .pipe(
+              Effect.withSpan("state_store.getStackOutput", {
+                attributes: {
+                  "alchemy.state_store.op": "getStackOutput",
+                  "alchemy.state_store.stack": params.stack,
+                  "alchemy.state_store.stage": params.stage,
+                },
+              }),
+            ),
+        )
+        .handle("setStackOutput", ({ params, payload }) =>
+          store
+            .getByName(params.stack)
+            .setOutput({ stage: params.stage, value: payload as any })
+            .pipe(
+              Effect.tap(() =>
+                store
+                  .getByName(Store.ROOT_DO_NAME)
+                  .registerStack({ stack: params.stack }),
+              ),
+              Effect.withSpan("state_store.setStackOutput", {
+                attributes: {
+                  "alchemy.state_store.op": "setStackOutput",
+                  "alchemy.state_store.stack": params.stack,
+                  "alchemy.state_store.stage": params.stage,
+                },
+              }),
+            ),
+        )
         .handle("deleteStack", ({ params, query }) =>
           store
             .getByName(params.stack)