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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.36",
+  "version": "2.0.0-beta.38",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/alchemy-run/alchemy-effect.git",
-    "directory": "package/alchemy"
+    "directory": "packages/alchemy"
   },
   "bin": {
     "alchemy": "./bin/cli.js"
@@ -40,12 +40,6 @@
       "worker": "./src/*.ts",
       "import": "./lib/*.js"
     },
-    "./Agent": {
-      "types": "./lib/Agent/index.d.ts",
-      "bun": "./src/Agent/index.ts",
-      "worker": "./src/Agent/index.ts",
-      "import": "./lib/Agent/index.js"
-    },
     "./Auth": {
       "types": "./lib/Auth/index.d.ts",
       "bun": "./src/Auth/index.ts",
@@ -196,6 +190,12 @@
       "worker": "./src/Output.ts",
       "import": "./lib/Output.js"
     },
+    "./Runtime": {
+      "types": "./lib/Runtime.d.ts",
+      "bun": "./src/Runtime.ts",
+      "worker": "./src/Runtime.ts",
+      "import": "./lib/Runtime.js"
+    },
     "./Process": {
       "types": "./lib/Process/index.d.ts",
       "bun": "./src/Process/index.ts",
@@ -270,35 +270,29 @@
     "access": "public"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.31",
-    "@ai-sdk/openai": "^3.0.23",
-    "@ai-sdk/provider": "^3.0.8",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "^0.19.0",
-    "@distilled.cloud/axiom": "^0.19.0",
-    "@distilled.cloud/cloudflare": "^0.19.0",
+    "@distilled.cloud/aws": "^0.20.1",
+    "@distilled.cloud/axiom": "^0.20.1",
+    "@distilled.cloud/cloudflare": "^0.20.1",
     "@distilled.cloud/cloudflare-rolldown-plugin": "0.3.0",
     "@distilled.cloud/cloudflare-runtime": "0.3.2",
     "@distilled.cloud/cloudflare-vite-plugin": "0.2.0",
-    "@distilled.cloud/core": "^0.19.0",
-    "@distilled.cloud/neon": "^0.19.0",
+    "@distilled.cloud/core": "^0.20.1",
+    "@distilled.cloud/neon": "^0.20.1",
     "pg": "^8.13.0",
-    "@effect/vitest": ">=4.0.0-beta.60 || >=4.0.0",
+    "@effect/vitest": ">=4.0.0-beta.66 || >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
     "@smithy/node-config-provider": "^4.0.0",
     "@smithy/shared-ini-file-loader": "^4.3.4",
     "@smithy/types": "^4.8.1",
     "@types/aws-lambda": "^8.10.152",
-    "@types/libsodium-wrappers": "^0.8.2",
-    "ai": "^6.0.62",
     "aws4fetch": "^1.0.20",
     "capnweb": "^0.6.1",
     "fast-glob": "^3.3.2",
     "fast-xml-parser": "^5.3.4",
     "foreground-child": "^4.0.3",
-    "ignore": "^7.0.5",
     "ink": "^6.3.1",
     "jszip": "^3.10.1",
     "libsodium-wrappers": "^0.8.3",
@@ -310,15 +304,14 @@
     "rolldown": "1.0.0-rc.17",
     "sonda": "^0.11.1",
     "undici": "^7.16.0",
-    "web-tree-sitter": "0.25.10",
     "yaml": "^2.0.0"
   },
   "devDependencies": {
     "@clack/prompts": "^0.11.0",
     "@cloudflare/workers-types": "^4.20250805.0",
-    "@effect/platform-bun": ">=4.0.0-beta.60 || >=4.0.0",
-    "@effect/platform-node": ">=4.0.0-beta.60 || >=4.0.0",
-    "@effect/platform-node-shared": ">=4.0.0-beta.60 || >=4.0.0",
+    "@effect/platform-bun": ">=4.0.0-beta.66 || >=4.0.0",
+    "@effect/platform-node": ">=4.0.0-beta.66 || >=4.0.0",
+    "@effect/platform-node-shared": ">=4.0.0-beta.66 || >=4.0.0",
     "@oxc-project/types": "^0.127.0",
     "@types/pg": "^8.11.0",
     "@types/aws-lambda": "^8.10.152",
@@ -329,7 +322,7 @@
     "@types/react": "^19.2.2",
     "@types/ws": "^8.18.1",
     "better-auth": "^1.6.2",
-    "effect": ">=4.0.0-beta.60 || >=4.0.0",
+    "effect": ">=4.0.0-beta.66 || >=4.0.0",
     "react-devtools-core": "^7.0.1",
     "solid-js": "latest",
     "tsconfig-paths": "^4.2.0",
@@ -339,12 +332,12 @@
     "ws": "^8.20.0"
   },
   "peerDependencies": {
-    "@effect/platform-bun": ">=4.0.0-beta.60 || >=4.0.0",
-    "@effect/platform-node": ">=4.0.0-beta.60 || >=4.0.0",
-    "@effect/sql-pg": ">=4.0.0-beta.60 || >=4.0.0",
+    "@effect/platform-bun": ">=4.0.0-beta.66 || >=4.0.0",
+    "@effect/platform-node": ">=4.0.0-beta.66 || >=4.0.0",
+    "@effect/sql-pg": ">=4.0.0-beta.66 || >=4.0.0",
     "drizzle-kit": ">=1.0.0-rc.1",
     "drizzle-orm": ">=1.0.0-rc.1",
-    "effect": ">=4.0.0-beta.60 || >=4.0.0",
+    "effect": ">=4.0.0-beta.66 || >=4.0.0",
     "vite": "^8.0.7",
     "ws": "^8.20.0"
   },

package/src/AWS/Credentials.ts

@@ -1,5 +1,4 @@
 import { Credentials } from "@distilled.cloud/aws/Credentials";
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { AWSEnvironment } from "./Environment.ts";
 
@@ -12,5 +11,5 @@ export { Credentials } from "@distilled.cloud/aws/Credentials";
  */
 export const fromEnvironment = Layer.effect(
   Credentials,
-  Effect.map(AWSEnvironment.asEffect(), (env) => env.credentials),
+  AWSEnvironment.useSync((env) => env.credentials),
 );

package/src/AWS/DynamoDB/Stream.ts

@@ -87,8 +87,5 @@ export const stream = <T extends Table>(
     process: (
       stream: Stream.Stream<StreamRecord<Data>, never, StreamReq>,
     ) => Effect.Effect<void, never, Req>,
-  ) =>
-    TableEventSource.asEffect().pipe(
-      Effect.flatMap((source) => source(table, props, process)),
-    ),
+  ) => TableEventSource.use((source) => source(table, props, process)),
 });

package/src/AWS/EC2/hosted.ts

@@ -96,23 +96,21 @@ export const createEc2HostRuntimeContext =
           return key;
         }),
       get: <T>(key: string) =>
-        Config.string(key)
-          .asEffect()
-          .pipe(
-            Effect.flatMap((value) =>
-              Effect.try({
-                try: () => JSON.parse(value) as T,
-                catch: (error) => error as Error,
+        Config.string(key).pipe(
+          Effect.flatMap((value) =>
+            Effect.try({
+              try: () => JSON.parse(value) as T,
+              catch: (error) => error as Error,
+            }),
+          ),
+          Effect.catch((cause) =>
+            Effect.die(
+              new Error(`Failed to get environment variable: ${key}`, {
+                cause,
               }),
             ),
-            Effect.catch((cause) =>
-              Effect.die(
-                new Error(`Failed to get environment variable: ${key}`, {
-                  cause,
-                }),
-              ),
-            ),
           ),
+        ),
       run: (effect: Effect.Effect<void, never, any>) =>
         Effect.sync(() => {
           runners.push(effect);
@@ -247,8 +245,8 @@ const program = handler.pipe(
     Layer.effect(
       Stack,
       Effect.all([
-        Config.string("ALCHEMY_STACK_NAME").asEffect(),
-        Config.string("ALCHEMY_STAGE").asEffect()
+        Config.string("ALCHEMY_STACK_NAME"),
+        Config.string("ALCHEMY_STAGE")
       ]).pipe(
         Effect.map(([name, stage]) => ({
           name,

package/src/AWS/ECS/Task.ts

@@ -191,23 +191,21 @@ export const Task: Platform<Task, TaskServices, TaskShape, TaskRuntimeContext> =
             return key;
           }),
         get: <T>(key: string) =>
-          Config.string(key)
-            .asEffect()
-            .pipe(
-              Effect.flatMap((value) =>
-                Effect.try({
-                  try: () => JSON.parse(value) as T,
-                  catch: (error) => error as Error,
+          Config.string(key).pipe(
+            Effect.flatMap((value) =>
+              Effect.try({
+                try: () => JSON.parse(value) as T,
+                catch: (error) => error as Error,
+              }),
+            ),
+            Effect.catch((cause) =>
+              Effect.die(
+                new Error(`Failed to get environment variable: ${key}`, {
+                  cause,
                 }),
               ),
-              Effect.catch((cause) =>
-                Effect.die(
-                  new Error(`Failed to get environment variable: ${key}`, {
-                    cause,
-                  }),
-                ),
-              ),
             ),
+          ),
         run: (effect: Effect.Effect<void, never, any>) =>
           Effect.sync(() => {
             runners.push(effect);
@@ -508,8 +506,8 @@ const program = handler.pipe(
     Layer.effect(
       Stack,
       Effect.all([
-        Config.string("ALCHEMY_STACK_NAME").asEffect(),
-        Config.string("ALCHEMY_STAGE").asEffect()
+        Config.string("ALCHEMY_STACK_NAME"),
+        Config.string("ALCHEMY_STAGE")
       ]).pipe(
         Effect.map(([name, stage]) => ({
           name,

package/src/AWS/Endpoint.ts

@@ -1,5 +1,4 @@
 import { Endpoint } from "@distilled.cloud/aws";
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { AWSEnvironment } from "./Environment.ts";
 
@@ -12,9 +11,7 @@ export const of = (endpoint: string) =>
  * Layer is empty (the SDK uses its default endpoint resolver).
  */
 export const fromEnvironment = Layer.unwrap(
-  AWSEnvironment.asEffect().pipe(
-    Effect.map((env) =>
-      env.endpoint === undefined ? Layer.empty : of(env.endpoint),
-    ),
+  AWSEnvironment.useSync((env) =>
+    env.endpoint === undefined ? Layer.empty : of(env.endpoint),
   ),
 );

package/src/AWS/EventBridge/EventSource.ts

@@ -68,10 +68,7 @@ export const events = (...args: any[]) => {
       process: (
         events: Stream.Stream<EventRecord<Detail>, never, StreamReq>,
       ) => Effect.Effect<void, never, Req>,
-    ) =>
-      EventSource.asEffect().pipe(
-        Effect.flatMap((source) => source(descriptor, process)),
-      ),
+    ) => EventSource.use((source) => source(descriptor, process)),
     toLambda: (fn: LambdaFunction, props: LambdaRouteTargetProps = {}) =>
       createLambdaRoute(descriptor, fn, props),
     toQueue: (queue: Queue, props: QueueRouteTargetProps = {}) =>

package/src/AWS/Kinesis/StreamEventSource.ts

@@ -99,8 +99,5 @@ export const records = <S extends KinesisStream>(
     process: (
       stream: Stream.Stream<KinesisEventRecord, never, StreamReq>,
     ) => Effect.Effect<void, never, Req>,
-  ) =>
-    StreamEventSource.asEffect().pipe(
-      Effect.flatMap((source) => source(stream, props, process)),
-    ),
+  ) => StreamEventSource.use((source) => source(stream, props, process)),
 });

package/src/AWS/Lambda/Function.ts

@@ -10,6 +10,7 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as Stream from "effect/Stream";
 import type * as rolldown from "rolldown";
@@ -368,27 +369,52 @@ export const Function: Platform<
       set: (id: string, output: Output.Output) =>
         Effect.sync(() => {
           const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
-          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          // Preserve `Redacted`-ness across the Output → Lambda env var
+          // round-trip. `JSON.stringify(Redacted)` would emit the literal
+          // string `"<redacted>"` and lose the value, so secrets are
+          // serialized with a `{_tag: "Redacted", value: ...}` marker
+          // that the runtime `get` path detects and rebuilds.
+          env[key] = output.pipe(
+            Output.map((value) =>
+              Redacted.isRedacted(value)
+                ? JSON.stringify({
+                    _tag: "Redacted",
+                    value: Redacted.value(value),
+                  })
+                : JSON.stringify(value),
+            ),
+          );
           return key;
         }),
       get: <T>(key: string) =>
-        Config.string(key)
-          .asEffect()
-          .pipe(
-            Effect.flatMap((val) =>
-              Effect.try({
-                try: () => JSON.parse(val) as T,
-                catch: () => val, // assume it's just a string
+        Config.string(key).pipe(
+          Effect.flatMap((val) =>
+            Effect.try({
+              try: () => {
+                const value = JSON.parse(val);
+                if (
+                  value !== null &&
+                  typeof value === "object" &&
+                  (value as { _tag?: unknown })._tag === "Redacted" &&
+                  "value" in (value as object)
+                ) {
+                  return Redacted.make(
+                    (value as { value: unknown }).value,
+                  ) as unknown as T;
+                }
+                return value as T;
+              },
+              catch: () => val, // assume it's just a string
+            }),
+          ),
+          Effect.catch((cause) =>
+            Effect.die(
+              new Error(`Failed to get environment variable: ${key}`, {
+                cause,
               }),
             ),
-            Effect.catch((cause) =>
-              Effect.die(
-                new Error(`Failed to get environment variable: ${key}`, {
-                  cause,
-                }),
-              ),
-            ),
           ),
+        ),
       serve: (handler: HttpEffect) =>
         ctx.listen(makeFunctionHttpHandler(handler)),
       listen: ((
@@ -641,6 +667,7 @@ export const FunctionProvider = () =>
                 (importPath) => `
 import { layer as nodeServicesLayer } from "@effect/platform-node/NodeServices";
 import { Stack } from "alchemy/Stack";
+import { makeEntrypointLayer } from "alchemy/Runtime";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Credentials from "@distilled.cloud/aws/Credentials";
@@ -652,13 +679,10 @@ import * as Region from "@distilled.cloud/aws/Region";
 import * as Context from "effect/Context";
 import { MinimumLogLevel } from "effect/References";
 
-import entry from "${importPath}";
+import entrypoint from "${importPath}";
 
 const tag = Context.Service("${Self.key}")
-const layer =
-  typeof entry?.build === "function"
-    ? entry
-    : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
+const layer = makeEntrypointLayer(tag, entrypoint);
 
 const platform = Layer.mergeAll(
   nodeServicesLayer,
@@ -670,8 +694,8 @@ const platform = Layer.mergeAll(
 const stack = Layer.effect(
   Stack,
   Effect.all([
-    Config.string("ALCHEMY_STACK_NAME").asEffect(),
-    Config.string("ALCHEMY_STAGE").asEffect()
+    Config.string("ALCHEMY_STACK_NAME"),
+    Config.string("ALCHEMY_STAGE")
   ]).pipe(
     Effect.map(([name, stage]) => ({
       name,
@@ -682,7 +706,7 @@ const stack = Layer.effect(
   )
 );
 
-const handlerEffect = tag.asEffect().pipe(
+const handlerEffect = tag.pipe(
   Effect.flatMap(func => func.RuntimeContext.exports),
   Effect.flatMap(exports => exports.handler),
   Effect.provide(

package/src/AWS/Providers.ts

@@ -15,13 +15,14 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
 import * as Schedule from "effect/Schedule";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { Command, CommandProvider } from "../Build/Command.ts";
 import * as Provider from "../Provider.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as ACM from "./ACM/index.ts";
 import * as ApiGateway from "./ApiGateway/index.ts";
 import * as Assets from "./Assets.ts";
-import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { AwsAuth } from "./AuthProvider.ts";
 import * as AutoScaling from "./AutoScaling/index.ts";
 import * as CloudFront from "./CloudFront/index.ts";
@@ -34,6 +35,7 @@ import * as ECS from "./ECS/index.ts";
 import * as EKS from "./EKS/index.ts";
 import * as ELBv2 from "./ELBv2/index.ts";
 import * as Endpoint from "./Endpoint.ts";
+import { Default as DefaultEnvironment } from "./Environment.ts";
 import * as EventBridge from "./EventBridge/index.ts";
 import * as IAM from "./IAM/index.ts";
 import * as IdentityCenter from "./IdentityCenter/index.ts";
@@ -50,7 +52,6 @@ import * as Scheduler from "./Scheduler/index.ts";
 import * as SecretsManager from "./SecretsManager/index.ts";
 import * as SNS from "./SNS/index.ts";
 import * as SQS from "./SQS/index.ts";
-import { Default as DefaultEnvironment } from "./Environment.ts";
 import * as Website from "./Website/index.ts";
 
 export class Providers extends Provider.ProviderCollection<Providers>()(
@@ -591,9 +592,27 @@ export const providers = () =>
     Layer.orDie,
   );
 
+// TODO(sam): remove this once it's upstreamed to distilled
+const isHttpTransportError = (error: unknown): boolean => {
+  if (!HttpClientError.isHttpClientError(error)) return false;
+  const tag = error.reason._tag;
+  if (tag === "TransportError") return true;
+  if (
+    tag === "StatusCodeError" &&
+    "response" in error.reason &&
+    error.reason.response.status >= 500
+  ) {
+    return true;
+  }
+  return false;
+};
+
 const awsRetryFactory: RetryFactory = (lastError) => ({
   while: (error) =>
-    isTransientError(error) || isThrottlingError(error) || isRetryable(error),
+    isTransientError(error) ||
+    isThrottlingError(error) ||
+    isRetryable(error) ||
+    isHttpTransportError(error),
   schedule: pipe(
     Schedule.exponential(Duration.millis(200), 2),
     Schedule.modifyDelay(

package/src/AWS/Region.ts

@@ -1,10 +1,9 @@
 import * as Region from "@distilled.cloud/aws/Region";
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { AWSEnvironment } from "./Environment.ts";
 
-export { Region } from "@distilled.cloud/aws/Region";
 export { AWS_REGION, type RegionID } from "./Environment.ts";
+export { Region } from "@distilled.cloud/aws/Region";
 
 export const of = (region: string) => Layer.succeed(Region.Region, region);
 
@@ -16,5 +15,5 @@ export const fromEnvOrElse = (region: string) =>
  */
 export const fromEnvironment = Layer.effect(
   Region.Region,
-  Effect.map(AWSEnvironment.asEffect(), (env) => env.region),
+  AWSEnvironment.useSync((env) => env.region),
 );

package/src/AWS/S3/Bucket.ts

@@ -564,12 +564,17 @@ export const BucketProvider = () =>
           yield* Effect.logInfo(
             `S3 Bucket delete: bucket=${output.bucketName} forceDestroy=${olds.forceDestroy ?? false}`,
           );
-          // If forceDestroy is enabled, delete all objects first
+          // If forceDestroy is enabled, delete all objects first. The bucket
+          // may already be gone (deleted out-of-band, or a previous destroy
+          // partially succeeded) — treat NoSuchBucket as a no-op so the
+          // overall delete still converges.
           if (olds.forceDestroy) {
             yield* session.note(
               `Force destroying bucket: ${output.bucketName} - deleting all objects...`,
             );
-            yield* deleteAllObjects(output.bucketName);
+            yield* deleteAllObjects(output.bucketName).pipe(
+              Effect.catchTag("NoSuchBucket", () => Effect.void),
+            );
           }
 
           yield* s3

package/src/AWS/S3/BucketNotifications.ts

@@ -70,8 +70,5 @@ export const notifications = <
     process: (
       stream: Stream.Stream<BucketNotification, never, StreamReq>,
     ) => Effect.Effect<void, never, Req>,
-  ) =>
-    BucketEventSource.asEffect().pipe(
-      Effect.flatMap((source) => source(bucket, props, process)),
-    ),
+  ) => BucketEventSource.use((source) => source(bucket, props, process)),
 });

package/src/AWS/SNS/TopicEventSource.ts

@@ -35,8 +35,5 @@ export const notifications = <T extends Topic>(
     process: (
       stream: Stream.Stream<TopicNotification, never, StreamReq>,
     ) => Effect.Effect<void, never, Req>,
-  ) =>
-    TopicEventSource.asEffect().pipe(
-      Effect.flatMap((source) => source(topic, props, process)),
-    ),
+  ) => TopicEventSource.use((source) => source(topic, props, process)),
 });

package/src/AWS/SQS/Queue.ts

@@ -313,12 +313,24 @@ export const QueueProvider = () =>
           // apply only the delta. SQS returns all attribute values as strings,
           // and `desiredAttributes` is already string-shaped, so equality
           // comparison is direct.
+          // SQS is eventually consistent: a freshly-created queue can return
+          // `QueueDoesNotExist` from `getQueueAttributes` for a few seconds
+          // even after `createQueue` succeeded. Retry briefly so the
+          // reconciler converges instead of failing the first deploy.
           const currentAttributes = yield* sqs
             .getQueueAttributes({
               QueueUrl: queueUrl,
               AttributeNames: ["All"],
             })
-            .pipe(Effect.map((r) => r.Attributes ?? {}));
+            .pipe(
+              Effect.retry({
+                while: (e) => e._tag === "QueueDoesNotExist",
+                schedule: Schedule.fixed(1000).pipe(
+                  Schedule.both(Schedule.recurs(30)),
+                ),
+              }),
+              Effect.map((r) => r.Attributes ?? {}),
+            );
 
           const attributeDelta: Record<string, string> = {};
           for (const [key, value] of Object.entries(desiredAttributes)) {
@@ -330,10 +342,19 @@ export const QueueProvider = () =>
             }
           }
           if (Object.keys(attributeDelta).length > 0) {
-            yield* sqs.setQueueAttributes({
-              QueueUrl: queueUrl,
-              Attributes: attributeDelta,
-            });
+            yield* sqs
+              .setQueueAttributes({
+                QueueUrl: queueUrl,
+                Attributes: attributeDelta,
+              })
+              .pipe(
+                Effect.retry({
+                  while: (e) => e._tag === "QueueDoesNotExist",
+                  schedule: Schedule.fixed(1000).pipe(
+                    Schedule.both(Schedule.recurs(30)),
+                  ),
+                }),
+              );
           }
 
           // Sync alchemy-owned tags. The `tags` parameter on `createQueue`
@@ -342,6 +363,12 @@ export const QueueProvider = () =>
           const currentTags = yield* sqs
             .listQueueTags({ QueueUrl: queueUrl })
             .pipe(
+              Effect.retry({
+                while: (e) => e._tag === "QueueDoesNotExist",
+                schedule: Schedule.fixed(1000).pipe(
+                  Schedule.both(Schedule.recurs(30)),
+                ),
+              }),
               Effect.map((r) => r.Tags ?? {}),
               Effect.catch(() => Effect.succeed({} as Record<string, string>)),
             );
@@ -352,7 +379,14 @@ export const QueueProvider = () =>
             }
           }
           if (Object.keys(tagDelta).length > 0) {
-            yield* sqs.tagQueue({ QueueUrl: queueUrl, Tags: tagDelta });
+            yield* sqs.tagQueue({ QueueUrl: queueUrl, Tags: tagDelta }).pipe(
+              Effect.retry({
+                while: (e) => e._tag === "QueueDoesNotExist",
+                schedule: Schedule.fixed(1000).pipe(
+                  Schedule.both(Schedule.recurs(30)),
+                ),
+              }),
+            );
           }
 
           yield* session.note(queueUrl);