alchemy 2.0.0-beta.52 → 2.0.0-beta.53

package/src/AWS/Bootstrap.ts

@@ -1,144 +1,91 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import type { BucketLocationConstraint } from "@distilled.cloud/aws/s3";
 import * as s3 from "@distilled.cloud/aws/s3";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
+import {
+  ASSETS_BUCKET_TAG,
+  createAssetsBucketName,
+  ensureAssetsBucketTags,
+  lookupAssetsBucket,
+  lookupAssetsBuckets,
+} from "./Assets.ts";
 import { AWSEnvironment } from "./Environment.ts";
 
 /**
- * Tag key used to identify the alchemy assets bucket.
- */
-export const ASSETS_BUCKET_TAG = "alchemy::assets-bucket";
-
-/**
- * Tag key used to scope the alchemy assets bucket to an AWS region.
- */
-export const ASSETS_BUCKET_REGION_TAG = "alchemy::assets-bucket-region";
-
-/**
- * Build an account-regional namespace bucket name.
- *
- * Account-regional buckets must follow the naming convention:
- *   `<prefix>-<accountId>-<region>-an`
+ * Bootstrap the AWS environment by creating the assets bucket.
  *
- * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/gpbucketnamespaces.html#account-regional-gp-buckets
+ * This is idempotent - running it multiple times is safe.
+ * The bucket is tagged and later discovered by tag lookup instead of by name.
  */
-const createAssetsBucketName = (accountId: string, region: string) =>
-  `alchemy-assets-${accountId}-${region}-an`.toLowerCase();
-
-const createAssetsBucketTags = (region: string) => [
-  { Key: ASSETS_BUCKET_TAG, Value: "true" },
-  { Key: ASSETS_BUCKET_REGION_TAG, Value: region },
-];
-
-const getBucketTags = (bucketName: string) =>
-  s3.getBucketTagging({ Bucket: bucketName }).pipe(
-    Effect.map((response) => response.TagSet ?? []),
-    Effect.catchTag("NoSuchTagSet", () =>
-      Effect.succeed<Array<{ Key?: string; Value?: string }>>([]),
-    ),
-  );
-
-const hasAssetsBucketTag = (tags: Array<{ Key?: string; Value?: string }>) =>
-  tags.some((tag) => tag.Key === ASSETS_BUCKET_TAG && tag.Value === "true");
+export const bootstrap = Effect.fn(function* () {
+  const { region } = yield* AWSEnvironment.current;
+  const existingBucket = yield* lookupAssetsBucket;
 
-const normalizeBucketRegion = (location: string | undefined) => {
-  if (!location) {
-    return "us-east-1";
-  }
-  if (location === "EU") {
-    return "eu-west-1";
+  if (Option.isSome(existingBucket)) {
+    yield* ensureAssetsBucketTags(existingBucket.value);
+    yield* Effect.logInfo(
+      `Assets bucket already exists: ${existingBucket.value}`,
+    );
+    return { bucketName: existingBucket.value, created: false };
   }
-  return location;
-};
-
-const bucketMatchesRegion = (
-  tags: Array<{ Key?: string; Value?: string }>,
-  region: string,
-) => {
-  const taggedRegion = tags.find(
-    (tag) => tag.Key === ASSETS_BUCKET_REGION_TAG,
-  )?.Value;
-  return taggedRegion === undefined ? undefined : taggedRegion === region;
-};
-
-export const lookupAssetsBuckets = Effect.gen(function* () {
-  const region = yield* Region;
-  const buckets = (yield* s3.listBuckets({})).Buckets ?? [];
-  const matchingBuckets: string[] = [];
-
-  for (const bucket of buckets) {
-    const bucketName = bucket.Name;
-    if (!bucketName) {
-      continue;
-    }
 
-    const tags = yield* getBucketTags(bucketName).pipe(
-      Effect.catch(() =>
-        Effect.succeed<Array<{ Key?: string; Value?: string }>>([]),
-      ),
+  const { accountId } = yield* AWSEnvironment.current;
+  const bucketName = createAssetsBucketName(accountId, region);
+  yield* s3
+    .createBucket({
+      Bucket: bucketName,
+      BucketNamespace: "account-regional",
+      CreateBucketConfiguration: {
+        Tags: [{ Key: ASSETS_BUCKET_TAG, Value: "true" }],
+        ...(region === "us-east-1"
+          ? {}
+          : { LocationConstraint: region as BucketLocationConstraint }),
+      },
+    })
+    .pipe(
+      Effect.catchTag("BucketAlreadyOwnedByYou", () => Effect.void),
+      Effect.retry({
+        while: (e) =>
+          e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
+        schedule: Schedule.exponential(100),
+      }),
     );
 
-    if (!hasAssetsBucketTag(tags)) {
-      continue;
-    }
-
-    const taggedRegionMatch = bucketMatchesRegion(tags, region);
-    if (taggedRegionMatch === true) {
-      matchingBuckets.push(bucketName);
-      continue;
-    }
-
-    if (taggedRegionMatch === false) {
-      continue;
-    }
-
-    const location = yield* s3.getBucketLocation({ Bucket: bucketName }).pipe(
-      Effect.map((response) =>
-        normalizeBucketRegion(response.LocationConstraint),
+  yield* s3.headBucket({ Bucket: bucketName }).pipe(
+    Effect.retry({
+      schedule: Schedule.exponential(100).pipe(
+        Schedule.both(Schedule.recurs(10)),
       ),
-      Effect.catch(() => Effect.succeed<string | undefined>(undefined)),
-    );
+    }),
+  );
 
-    if (location === region) {
-      matchingBuckets.push(bucketName);
-    }
-  }
+  yield* Effect.logInfo(`Created assets bucket: ${bucketName}`);
 
-  return matchingBuckets;
+  return { bucketName, created: true };
 });
 
-export const lookupAssetsBucket = Effect.gen(function* () {
-  const matchingBuckets = yield* lookupAssetsBuckets;
-  for (const bucketName of matchingBuckets) {
-    return Option.some(bucketName);
-  }
-  return Option.none<string>();
-});
+export const destroyBootstrap = Effect.fn(function* () {
+  const bucketNames = yield* lookupAssetsBuckets;
 
-const ensureAssetsBucketTags = Effect.fn(function* (
-  bucketName: string,
-  region: string,
-) {
-  const existingTags = yield* getBucketTags(bucketName);
-  const tagSet = [
-    ...existingTags.filter(
-      (tag) =>
-        tag.Key !== ASSETS_BUCKET_TAG && tag.Key !== ASSETS_BUCKET_REGION_TAG,
-    ),
-    ...createAssetsBucketTags(region),
-  ];
+  for (const bucketName of bucketNames) {
+    yield* Effect.logInfo(`Destroying assets bucket: ${bucketName}`);
+    yield* deleteAllObjects(bucketName);
+    yield* s3.deleteBucket({ Bucket: bucketName }).pipe(
+      Effect.retry({
+        while: (e) =>
+          e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
+        schedule: Schedule.exponential(100).pipe(
+          Schedule.both(Schedule.recurs(10)),
+        ),
+      }),
+    );
+  }
 
-  yield* s3.putBucketTagging({
-    Bucket: bucketName,
-    Tagging: {
-      TagSet: tagSet.map((tag) => ({
-        Key: tag.Key!,
-        Value: tag.Value!,
-      })),
-    },
-  });
+  return {
+    bucketNames,
+    destroyed: bucketNames.length,
+  };
 });
 
 const deleteAllObjects = Effect.fn(function* (bucketName: string) {
@@ -198,79 +145,3 @@ const deleteAllObjects = Effect.fn(function* (bucketName: string) {
     versionIdMarker = listVersionsResponse.NextVersionIdMarker;
   } while (keyMarker);
 });
-
-/**
- * Bootstrap the AWS environment by creating the assets bucket.
- *
- * This is idempotent - running it multiple times is safe.
- * The bucket is tagged and later discovered by tag lookup instead of by name.
- */
-export const bootstrap = Effect.fn(function* () {
-  const region = yield* Region;
-  const existingBucket = yield* lookupAssetsBucket;
-
-  if (Option.isSome(existingBucket)) {
-    yield* ensureAssetsBucketTags(existingBucket.value, region);
-    yield* Effect.logInfo(
-      `Assets bucket already exists: ${existingBucket.value}`,
-    );
-    return { bucketName: existingBucket.value, created: false };
-  }
-
-  const { accountId } = yield* AWSEnvironment;
-  const bucketName = createAssetsBucketName(accountId, region);
-  yield* s3
-    .createBucket({
-      Bucket: bucketName,
-      BucketNamespace: "account-regional",
-      CreateBucketConfiguration: {
-        Tags: createAssetsBucketTags(region),
-        ...(region === "us-east-1"
-          ? {}
-          : { LocationConstraint: region as BucketLocationConstraint }),
-      },
-    })
-    .pipe(
-      Effect.catchTag("BucketAlreadyOwnedByYou", () => Effect.void),
-      Effect.retry({
-        while: (e) =>
-          e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
-        schedule: Schedule.exponential(100),
-      }),
-    );
-
-  yield* s3.headBucket({ Bucket: bucketName }).pipe(
-    Effect.retry({
-      schedule: Schedule.exponential(100).pipe(
-        Schedule.both(Schedule.recurs(10)),
-      ),
-    }),
-  );
-
-  yield* Effect.logInfo(`Created assets bucket: ${bucketName}`);
-
-  return { bucketName, created: true };
-});
-
-export const destroyBootstrap = Effect.fn(function* () {
-  const bucketNames = yield* lookupAssetsBuckets;
-
-  for (const bucketName of bucketNames) {
-    yield* Effect.logInfo(`Destroying assets bucket: ${bucketName}`);
-    yield* deleteAllObjects(bucketName);
-    yield* s3.deleteBucket({ Bucket: bucketName }).pipe(
-      Effect.retry({
-        while: (e) =>
-          e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
-        schedule: Schedule.exponential(100).pipe(
-          Schedule.both(Schedule.recurs(10)),
-        ),
-      }),
-    );
-  }
-
-  return {
-    bucketNames,
-    destroyed: bucketNames.length,
-  };
-});

package/src/AWS/CloudWatch/Alarm.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
 import * as Effect from "effect/Effect";
 import { Unowned } from "../../AdoptPolicy.ts";
@@ -6,8 +5,8 @@ import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { hasAlchemyTags } from "../../Tags.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 import {
   createName,
@@ -73,14 +72,16 @@ export const AlarmProvider = () =>
   Provider.effect(
     Alarm,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createAlarmName = (id: string, props: { name?: string } = {}) =>
         createName(id, props.name, 255);
 
       const alarmArn = (alarmName: string) =>
-        `arn:aws:cloudwatch:${region}:${accountId}:alarm:${alarmName}` as AlarmArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch:${env.region}:${env.accountId}:alarm:${alarmName}` as AlarmArn,
+          ),
+        );
 
       const readAlarm = Effect.fn(function* (alarmName: string) {
         const described = yield* cloudwatch.describeAlarms({
@@ -153,12 +154,12 @@ export const AlarmProvider = () =>
           // fall back to whatever we just observed.
           const tags = yield* updateResourceTags({
             id,
-            resourceArn: alarmArn(name),
+            resourceArn: yield* alarmArn(name),
             olds: olds?.tags ?? existing?.tags,
             news: news.tags,
           });
 
-          yield* session.note(alarmArn(name));
+          yield* session.note(yield* alarmArn(name));
 
           const state = yield* readAlarm(name);
           if (!state) {

package/src/AWS/CloudWatch/AlarmMuteRule.ts

@@ -1,11 +1,10 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
 import * as Effect from "effect/Effect";
 import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 import { createManagedTags, createName, retryConcurrent } from "./common.ts";
 
@@ -66,14 +65,16 @@ export const AlarmMuteRuleProvider = () =>
   Provider.effect(
     AlarmMuteRule,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createMuteRuleName = (id: string, props: { name?: string } = {}) =>
         createName(id, props.name, 255);
 
       const alarmMuteRuleArn = (name: string) =>
-        `arn:aws:cloudwatch:${region}:${accountId}:alarm-mute-rule:${name}` as AlarmMuteRuleArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch:${env.region}:${env.accountId}:alarm-mute-rule:${name}` as AlarmMuteRuleArn,
+          ),
+        );
 
       const readAlarmMuteRule = Effect.fn(function* (name: string) {
         const output = yield* cloudwatch
@@ -139,7 +140,7 @@ export const AlarmMuteRuleProvider = () =>
             }),
           );
 
-          yield* session.note(alarmMuteRuleArn(name));
+          yield* session.note(yield* alarmMuteRuleArn(name));
 
           const state = yield* readAlarmMuteRule(name);
           if (!state) {

package/src/AWS/CloudWatch/CompositeAlarm.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
 import * as Effect from "effect/Effect";
 import { Unowned } from "../../AdoptPolicy.ts";
@@ -6,8 +5,8 @@ import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { hasAlchemyTags } from "../../Tags.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { AlarmArn } from "./Alarm.ts";
 import {
   createName,
@@ -66,14 +65,16 @@ export const CompositeAlarmProvider = () =>
   Provider.effect(
     CompositeAlarm,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createAlarmName = (id: string, props: { name?: string } = {}) =>
         createName(id, props.name, 255);
 
       const alarmArn = (alarmName: string) =>
-        `arn:aws:cloudwatch:${region}:${accountId}:alarm:${alarmName}` as AlarmArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch:${env.region}:${env.accountId}:alarm:${alarmName}` as AlarmArn,
+          ),
+        );
 
       const readCompositeAlarm = Effect.fn(function* (alarmName: string) {
         const described = yield* cloudwatch.describeAlarms({
@@ -146,12 +147,12 @@ export const CompositeAlarmProvider = () =>
           // observed.
           const tags = yield* updateResourceTags({
             id,
-            resourceArn: alarmArn(name),
+            resourceArn: yield* alarmArn(name),
             olds: olds?.tags ?? existing?.tags,
             news: news.tags,
           });
 
-          yield* session.note(alarmArn(name));
+          yield* session.note(yield* alarmArn(name));
 
           const state = yield* readCompositeAlarm(name);
           if (!state) {

package/src/AWS/CloudWatch/Dashboard.ts

@@ -3,8 +3,8 @@ import * as Effect from "effect/Effect";
 import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import { createName, retryConcurrent } from "./common.ts";
 
 export type DashboardName = string;
@@ -163,13 +163,16 @@ export const DashboardProvider = () =>
   Provider.effect(
     Dashboard,
     Effect.gen(function* () {
-      const { accountId } = yield* AWSEnvironment;
-
       const createDashboardName = (id: string, props: { name?: string } = {}) =>
         createName(id, props.name, 255);
 
       const dashboardArn = (dashboardName: string) =>
-        `arn:aws:cloudwatch::${accountId}:dashboard/${dashboardName}` as DashboardArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch::${env.accountId}:dashboard/${dashboardName}` as DashboardArn,
+          ),
+        );
 
       const readDashboard = Effect.fn(function* (dashboardName: string) {
         const output = yield* cloudwatch
@@ -188,7 +191,7 @@ export const DashboardProvider = () =>
 
         return {
           dashboardName: output.DashboardName,
-          dashboardArn: dashboardArn(output.DashboardName),
+          dashboardArn: yield* dashboardArn(output.DashboardName),
           dashboardBody: parseDashboardBody(output.DashboardBody),
           tags: {},
         };
@@ -232,7 +235,7 @@ export const DashboardProvider = () =>
             }),
           );
 
-          yield* session.note(dashboardArn(name));
+          yield* session.note(yield* dashboardArn(name));
 
           const state = yield* readDashboard(name);
           if (!state) {

package/src/AWS/CloudWatch/InsightRule.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -9,8 +8,8 @@ import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { hasAlchemyTags } from "../../Tags.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 import {
   createName,
@@ -121,14 +120,16 @@ export const InsightRuleProvider = () =>
   Provider.effect(
     InsightRule,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createRuleName = (id: string, props: { name?: string } = {}) =>
         createName(id, props.name, 255);
 
       const ruleArn = (name: string) =>
-        `arn:aws:cloudwatch:${region}:${accountId}:insight-rule/${name}` as InsightRuleArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch:${env.region}:${env.accountId}:insight-rule/${name}` as InsightRuleArn,
+          ),
+        );
 
       const readInsightRule = Effect.fn(function* (name: string) {
         const insightRule = yield* cloudwatch.describeInsightRules
@@ -150,7 +151,7 @@ export const InsightRuleProvider = () =>
           return undefined;
         }
 
-        const arn = ruleArn(insightRule.Name);
+        const arn = yield* ruleArn(insightRule.Name);
         const tags = yield* readResourceTags(arn).pipe(
           Effect.catchTag("ResourceNotFoundException", () =>
             Effect.succeed({}),
@@ -211,12 +212,12 @@ export const InsightRuleProvider = () =>
           // the latter path.
           const tags = yield* updateResourceTags({
             id,
-            resourceArn: ruleArn(name),
+            resourceArn: yield* ruleArn(name),
             olds: olds?.tags ?? existing?.tags,
             news: news.tags,
           });
 
-          yield* session.note(ruleArn(name));
+          yield* session.note(yield* ruleArn(name));
 
           const state = yield* readInsightRule(name);
           if (!state) {

package/src/AWS/CloudWatch/MetricStream.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as cloudwatch from "@distilled.cloud/aws/cloudwatch";
 import * as Effect from "effect/Effect";
 import { Unowned } from "../../AdoptPolicy.ts";
@@ -7,8 +6,8 @@ import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { hasAlchemyTags } from "../../Tags.ts";
-import type { Providers } from "../Providers.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 import {
   createName,
@@ -75,15 +74,18 @@ export const MetricStreamProvider = () =>
   Provider.effect(
     MetricStream,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
       const createMetricStreamName = (
         id: string,
         props: { name?: string } = {},
       ) => createName(id, props.name, 255);
 
       const metricStreamArn = (name: string) =>
-        `arn:aws:cloudwatch:${region}:${accountId}:metric-stream/${name}` as MetricStreamArn;
+        AWSEnvironment.current.pipe(
+          Effect.map(
+            (env) =>
+              `arn:aws:cloudwatch:${env.region}:${env.accountId}:metric-stream/${name}` as MetricStreamArn,
+          ),
+        );
 
       const readMetricStream = Effect.fn(function* (name: string) {
         const output = yield* cloudwatch
@@ -198,12 +200,12 @@ export const MetricStreamProvider = () =>
           // otherwise fall back to what we observed (adoption path).
           const tags = yield* updateResourceTags({
             id,
-            resourceArn: metricStreamArn(name),
+            resourceArn: yield* metricStreamArn(name),
             olds: olds?.tags ?? existing?.tags,
             news: news.tags,
           });
 
-          yield* session.note(metricStreamArn(name));
+          yield* session.note(yield* metricStreamArn(name));
 
           const state = yield* readMetricStream(name);
           if (!state) {

package/src/AWS/Credentials.ts

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

package/src/AWS/EC2/EIP.ts

@@ -1,14 +1,13 @@
 import * as ec2 from "@distilled.cloud/aws/ec2";
-import { Region } from "@distilled.cloud/aws/Region";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, createTagsList, diffTags } from "../../Tags.ts";
 import type { AccountID } from "../Environment.ts";
 import { AWSEnvironment } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 
 export type EIPArn =
@@ -109,9 +108,6 @@ export const EIPProvider = () =>
   Provider.effect(
     EIP,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createTags = Effect.fn(function* (
         id: string,
         tags?: Record<string, string>,
@@ -127,6 +123,8 @@ export const EIPProvider = () =>
         stables: ["allocationId", "eipArn", "publicIp"],
 
         read: Effect.fn(function* ({ output }) {
+          const { region, accountId } = yield* AWSEnvironment.current;
+
           if (!output) return undefined;
           const result = yield* ec2.describeAddresses({
             AllocationIds: [output.allocationId],
@@ -167,6 +165,8 @@ export const EIPProvider = () =>
         }),
 
         reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
+          const { region, accountId } = yield* AWSEnvironment.current;
+
           const desiredTags = yield* createTags(id, news.tags);
 
           // Observe — try to find an existing EIP via the cached allocationId.