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

package/src/AWS/EC2/Vpc.ts

@@ -1,6 +1,5 @@
 import * as EC2 from "@distilled.cloud/aws/ec2";
 import * as ec2 from "@distilled.cloud/aws/ec2";
-import { Region } from "@distilled.cloud/aws/Region";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
@@ -8,10 +7,10 @@ import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved, somePropsAreDifferent } 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 VpcId = `vpc-${string}`;
@@ -169,9 +168,6 @@ export const VpcProvider = () =>
   Provider.effect(
     Vpc,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createTags = Effect.fn(function* (
         id: string,
         tags?: Record<string, string>,
@@ -201,6 +197,7 @@ export const VpcProvider = () =>
         }),
 
         reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
+          const { accountId, region } = yield* AWSEnvironment.current;
           const desiredTags = yield* createTags(id, news.tags);
 
           // Observe — find the VPC if we already have its id, else describe

package/src/AWS/EC2/VpcEndpoint.ts

@@ -1,6 +1,5 @@
 import type * as EC2 from "@distilled.cloud/aws/ec2";
 import * as ec2 from "@distilled.cloud/aws/ec2";
-import { Region } from "@distilled.cloud/aws/Region";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
@@ -219,9 +218,6 @@ export const VpcEndpointProvider = () =>
   Provider.effect(
     VpcEndpoint,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createTags = Effect.fn(function* (
         id: string,
         tags?: Record<string, string>,
@@ -244,48 +240,52 @@ export const VpcEndpointProvider = () =>
                 ),
           ),
         );
+      // const { accountId, region } = yield* AWSEnvironment.current;
 
-      const toAttrs = (ep: ec2.VpcEndpoint): VpcEndpoint["Attributes"] => ({
-        vpcEndpointId: ep.VpcEndpointId as VpcEndpointId,
-        vpcEndpointArn:
-          `arn:aws:ec2:${region}:${accountId}:vpc-endpoint/${ep.VpcEndpointId}` as VpcEndpointArn,
-        vpcEndpointType: ep.VpcEndpointType!,
-        vpcId: ep.VpcId as VpcId,
-        serviceName: ep.ServiceName!,
-        state: ep.State!,
-        policyDocument: ep.PolicyDocument,
-        routeTableIds: ep.RouteTableIds,
-        subnetIds: ep.SubnetIds,
-        groups: ep.Groups?.map((g) => ({
-          groupId: g.GroupId!,
-          groupName: g.GroupName!,
-        })),
-        privateDnsEnabled: ep.PrivateDnsEnabled,
-        requesterManaged: ep.RequesterManaged,
-        networkInterfaceIds: ep.NetworkInterfaceIds,
-        dnsEntries: ep.DnsEntries?.map((d) => ({
-          dnsName: d.DnsName,
-          hostedZoneId: d.HostedZoneId,
-        })),
-        creationTimestamp:
-          ep.CreationTimestamp instanceof Date
-            ? ep.CreationTimestamp.toISOString()
-            : (ep.CreationTimestamp as string | undefined),
-        ownerId: ep.OwnerId,
-        ipAddressType: ep.IpAddressType,
-        dnsOptions: ep.DnsOptions
-          ? {
-              dnsRecordIpType: ep.DnsOptions.DnsRecordIpType,
-              privateDnsOnlyForInboundResolverEndpoint:
-                ep.DnsOptions.PrivateDnsOnlyForInboundResolverEndpoint,
-            }
-          : undefined,
-        lastError: ep.LastError
-          ? {
-              code: ep.LastError.Code,
-              message: ep.LastError.Message,
-            }
-          : undefined,
+      const toAttrs = Effect.fnUntraced(function* (ep: ec2.VpcEndpoint) {
+        const { accountId, region } = yield* AWSEnvironment.current;
+        return {
+          vpcEndpointId: ep.VpcEndpointId as VpcEndpointId,
+          vpcEndpointArn:
+            `arn:aws:ec2:${region}:${accountId}:vpc-endpoint/${ep.VpcEndpointId}` as VpcEndpointArn,
+          vpcEndpointType: ep.VpcEndpointType!,
+          vpcId: ep.VpcId as VpcId,
+          serviceName: ep.ServiceName!,
+          state: ep.State!,
+          policyDocument: ep.PolicyDocument,
+          routeTableIds: ep.RouteTableIds,
+          subnetIds: ep.SubnetIds,
+          groups: ep.Groups?.map((g) => ({
+            groupId: g.GroupId!,
+            groupName: g.GroupName!,
+          })),
+          privateDnsEnabled: ep.PrivateDnsEnabled,
+          requesterManaged: ep.RequesterManaged,
+          networkInterfaceIds: ep.NetworkInterfaceIds,
+          dnsEntries: ep.DnsEntries?.map((d) => ({
+            dnsName: d.DnsName,
+            hostedZoneId: d.HostedZoneId,
+          })),
+          creationTimestamp:
+            ep.CreationTimestamp instanceof Date
+              ? ep.CreationTimestamp.toISOString()
+              : (ep.CreationTimestamp as string | undefined),
+          ownerId: ep.OwnerId,
+          ipAddressType: ep.IpAddressType,
+          dnsOptions: ep.DnsOptions
+            ? {
+                dnsRecordIpType: ep.DnsOptions.DnsRecordIpType,
+                privateDnsOnlyForInboundResolverEndpoint:
+                  ep.DnsOptions.PrivateDnsOnlyForInboundResolverEndpoint,
+              }
+            : undefined,
+          lastError: ep.LastError
+            ? {
+                code: ep.LastError.Code,
+                message: ep.LastError.Message,
+              }
+            : undefined,
+        } satisfies VpcEndpoint["Attributes"];
       });
 
       return {
@@ -294,7 +294,7 @@ export const VpcEndpointProvider = () =>
         read: Effect.fn(function* ({ output }) {
           if (!output) return undefined;
           const ep = yield* describeVpcEndpoint(output.vpcEndpointId);
-          return toAttrs(ep);
+          return yield* toAttrs(ep);
         }),
 
         diff: Effect.fn(function* ({ news, olds }) {
@@ -520,7 +520,7 @@ export const VpcEndpointProvider = () =>
 
           // Re-read final state.
           const final = yield* describeVpcEndpoint(vpcEndpointId);
-          return toAttrs(final);
+          return yield* toAttrs(final);
         }),
 
         delete: Effect.fn(function* ({ output, session }) {

package/src/AWS/EC2/hosted.ts

@@ -16,6 +16,7 @@ import { createInternalTags, createTagsList, hasTags } from "../../Tags.ts";
 import { sha256 } from "../../Util/sha256.ts";
 import { zipCode } from "../../Util/zip.ts";
 import { Assets } from "../Assets.ts";
+import { AWSEnvironment } from "../Environment.ts";
 import type { PolicyStatement } from "../IAM/Policy.ts";
 
 export interface Ec2HostedBinding {
@@ -122,24 +123,18 @@ export const createEc2HostRuntimeContext =
   };
 
 export const createEc2HostedSupport = ({
-  accountId,
-  region,
   stackName,
   stage,
   fs,
   virtualEntryPlugin,
-  assets,
   resourceType,
 }: {
-  accountId: string;
-  region: string;
   stackName: string;
   stage: string;
   fs: FileSystem.FileSystem;
   virtualEntryPlugin: (
     content: (importPath: string) => string,
   ) => rolldown.Plugin;
-  assets: typeof Assets.Service | undefined;
   resourceType: string;
 }) => {
   const alchemyEnv = {
@@ -297,15 +292,17 @@ await Effect.runPromise(program);
       .map(([key, value]) => `${key}=${quoteEnvValue(value)}`)
       .join("\n");
 
-  const renderHostedUserData = ({
+  const renderHostedUserData = Effect.fnUntraced(function* ({
     unitName,
     bundleKey,
     envKey,
+    region,
   }: {
     unitName: string;
     bundleKey: string;
     envKey: string;
-  }) => {
+    region: string;
+  }) {
     const appDir = `/opt/${unitName}`;
     return `#!/bin/bash
 set -euo pipefail
@@ -332,8 +329,8 @@ cat >/usr/local/bin/${unitName}-sync.sh <<'EOF'
 #!/bin/bash
 set -euo pipefail
 mkdir -p "${appDir}"
-aws s3 cp "s3://${assets?.bucketName}/${bundleKey}" "${appDir}/bundle.zip" --region "${region}"
-aws s3 cp "s3://${assets?.bucketName}/${envKey}" "${appDir}/env" --region "${region}"
+aws s3 cp "s3://${yield* Assets.BucketName}/${bundleKey}" "${appDir}/bundle.zip" --region "${region}"
+aws s3 cp "s3://${yield* Assets.BucketName}/${envKey}" "${appDir}/env" --region "${region}"
 rm -f "${appDir}/index.mjs"
 unzip -o "${appDir}/bundle.zip" -d "${appDir}"
 EOF
@@ -362,7 +359,7 @@ EOF
 systemctl daemon-reload
 systemctl enable --now ${unitName}.service
 `;
-  };
+  });
 
   const mergeUserData = (hosted: string, userData?: string) => {
     if (!userData) {
@@ -414,6 +411,7 @@ systemctl enable --now ${unitName}.service
     roleName: string;
     managedPolicyArns: string[];
   }) {
+    const { accountId } = yield* AWSEnvironment.current;
     const tags = yield* createInternalTags(id);
     const role = yield* iam
       .createRole({
@@ -533,7 +531,7 @@ systemctl enable --now ${unitName}.service
       Sid: undefined,
       Effect: "Allow",
       Action: ["s3:GetObject"],
-      Resource: [`arn:aws:s3:::${assets?.bucketName}/${assetPrefix}/*`],
+      Resource: [`arn:aws:s3:::${yield* Assets.BucketName}/${assetPrefix}/*`],
     });
 
     yield* iam.putRolePolicy({
@@ -559,23 +557,16 @@ systemctl enable --now ${unitName}.service
     archive: Uint8Array<ArrayBufferLike>;
     env: Record<string, any>;
   }) {
-    if (!assets) {
-      return yield* Effect.fail(
-        new Error(
-          `${resourceType} host mode requires the AWS assets bucket. Run bootstrap first.`,
-        ),
-      );
-    }
-
+    const assets = yield* Assets;
     const contentHash = yield* sha256(archive);
     const uploadedAssetKey = yield* assets.uploadAsset(contentHash, archive);
     yield* s3.copyObject({
-      Bucket: assets.bucketName,
+      Bucket: yield* assets.bucketName,
       Key: bundleKey,
-      CopySource: `${assets.bucketName}/${uploadedAssetKey}`,
+      CopySource: `${yield* assets.bucketName}/${uploadedAssetKey}`,
     });
     yield* s3.putObject({
-      Bucket: assets.bucketName,
+      Bucket: yield* assets.bucketName,
       Key: envKey,
       Body: renderEnvFile(env),
       ContentType: "text/plain; charset=utf-8",
@@ -619,14 +610,8 @@ systemctl enable --now ${unitName}.service
         ),
       );
     }
-    if (!assets) {
-      return yield* Effect.fail(
-        new Error(
-          `${resourceType} host mode requires the AWS assets bucket. Run bootstrap first.`,
-        ),
-      );
-    }
 
+    const { region } = yield* AWSEnvironment.current;
     const runtimeUnitName =
       output?.runtimeUnitName ?? (yield* createRuntimeUnitName(id));
     const assetPrefix = output?.assetPrefix ?? `ec2/${runtimeUnitName}`;
@@ -697,10 +682,11 @@ systemctl enable --now ${unitName}.service
       env,
     });
 
-    const hostedUserData = renderHostedUserData({
+    const hostedUserData = yield* renderHostedUserData({
       unitName: runtimeUnitName,
       bundleKey,
       envKey,
+      region,
     });
 
     return {
@@ -765,14 +751,14 @@ systemctl enable --now ${unitName}.service
         .pipe(Effect.catchTag("NoSuchEntityException", () => Effect.void));
     }
 
-    if (assets && output.assetPrefix) {
+    if (output.assetPrefix) {
       for (const key of [
         `${output.assetPrefix}/bundle.zip`,
         `${output.assetPrefix}/env`,
       ]) {
         yield* s3
           .deleteObject({
-            Bucket: assets.bucketName,
+            Bucket: yield* Assets.BucketName,
             Key: key,
           })
           .pipe(Effect.catchTag("NotFound", () => Effect.void));

package/src/AWS/ECS/CapacityProvider.ts

@@ -1,5 +1,4 @@
 import * as ecs from "@distilled.cloud/aws/ecs";
-import { Region } from "@distilled.cloud/aws/Region";
 import * as Effect from "effect/Effect";
 import { Unowned } from "../../AdoptPolicy.ts";
 import { isResolved } from "../../Diff.ts";
@@ -200,8 +199,7 @@ export const CapacityProviderProvider = () =>
         }),
 
         reconcile: Effect.fn(function* ({ id, news, session }) {
-          const region = yield* Region;
-          const { accountId } = yield* AWSEnvironment;
+          const { accountId, region } = yield* AWSEnvironment.current;
           const name = yield* toName(id, news);
           const internalTags = yield* createInternalTags(id);
           const desiredTags = { ...internalTags, ...news.tags };

package/src/AWS/ECS/Cluster.ts

@@ -1,13 +1,12 @@
 import * as ecs from "@distilled.cloud/aws/ecs";
-import { Region } from "@distilled.cloud/aws/Region";
 import * as Effect from "effect/Effect";
 import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, diffTags } from "../../Tags.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 
 export type ClusterName = string;
@@ -78,9 +77,6 @@ export const ClusterProvider = () =>
   Provider.effect(
     Cluster,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const toEcsTags = (tags: Record<string, string>): ecs.Tag[] =>
         Object.entries(tags).map(([key, value]) => ({
           key,
@@ -155,6 +151,7 @@ export const ClusterProvider = () =>
           };
         }),
         reconcile: Effect.fn(function* ({ id, news, session }) {
+          const { accountId, region } = yield* AWSEnvironment.current;
           const clusterName = yield* toClusterName(id, news);
           const clusterArn =
             `arn:aws:ecs:${region}:${accountId}:cluster/${clusterName}` as ClusterArn;

package/src/AWS/ECS/Task.ts

@@ -164,7 +164,7 @@ export interface Task extends Resource<
   Providers
 > {}
 
-export type TaskServices = Credentials | Region | ServerHost;
+export type TaskServices = Credentials | Region | ServerHost | AWSEnvironment;
 
 export type TaskShape = Main<TaskServices>;
 
@@ -219,8 +219,7 @@ export const TaskProvider = () =>
     Task,
     Effect.gen(function* () {
       const stack = yield* Stack;
-      const { accountId } = yield* AWSEnvironment;
-      const region = yield* Region;
+
       const { dotAlchemy } = yield* AlchemyContext;
       const fs = yield* FileSystem.FileSystem;
       const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
@@ -380,6 +379,7 @@ export const TaskProvider = () =>
         id: string;
         logGroupName: string;
       }) {
+        const { accountId, region } = yield* AWSEnvironment.current;
         const tags = yield* createInternalTags(id);
         yield* logs
           .createLogGroup({
@@ -630,6 +630,7 @@ await Effect.runPromise(program);
         executionRoleArn: string;
         logGroupName: string;
       }) {
+        const { region } = yield* AWSEnvironment.current;
         const containerName = props.container?.name ?? family;
         const response = yield* ecs.registerTaskDefinition({
           family,

package/src/AWS/Endpoint.ts

@@ -1,17 +1,23 @@
 import { Endpoint } from "@distilled.cloud/aws";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { AWSEnvironment } from "./Environment.ts";
 
 export const of = (endpoint: string) =>
-  Layer.succeed(Endpoint.Endpoint, endpoint);
+  Layer.succeed(Endpoint.Endpoint, Effect.succeed(endpoint));
 
 /**
  * Derive a custom endpoint (if any) from the surrounding
  * {@link AWSEnvironment}. If the environment has no `endpoint` set, this
  * Layer is empty (the SDK uses its default endpoint resolver).
  */
-export const fromEnvironment = Layer.unwrap(
-  AWSEnvironment.useSync((env) =>
-    env.endpoint === undefined ? Layer.empty : of(env.endpoint),
-  ),
-);
+export const fromEnvironment: Layer.Layer<never, never, AWSEnvironment> =
+  Layer.effect(
+    Endpoint.Endpoint,
+    Effect.gen(function* () {
+      return Effect.map(
+        yield* AWSEnvironment,
+        (env) => env.endpoint ?? undefined!,
+      );
+    }),
+  );

package/src/AWS/Environment.ts

@@ -1,17 +1,19 @@
-import * as Auth from "@distilled.cloud/aws/Auth";
 import {
-  fromAwsCredentialIdentity,
   type CredentialsError,
   type ResolvedCredentials,
 } from "@distilled.cloud/aws/Credentials";
-import type { AwsCredentialIdentity } from "@smithy/types";
 import * as Config from "effect/Config";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Redacted from "effect/Redacted";
+import { getAuthProvider } from "../Auth/AuthProvider.ts";
+import { ALCHEMY_PROFILE, AlchemyProfile } from "../Auth/Profile.ts";
+import {
+  AWS_AUTH_PROVIDER_NAME,
+  type AwsAuthConfig,
+  type AwsResolvedCredentials,
+} from "./AuthProvider.ts";
 
 export const AWS_PROFILE = Config.string("AWS_PROFILE").pipe(
   Config.withDefault("default"),
@@ -53,125 +55,25 @@ export interface AWSEnvironmentShape {
 
 export class AWSEnvironment extends Context.Service<
   AWSEnvironment,
-  AWSEnvironmentShape
->()("AWS::Environment") {}
+  Effect.Effect<AWSEnvironmentShape>
+>()("AWS::Environment") {
+  static current = AWSEnvironment.use((env) => env);
+}
 
-/**
- * Build an `AWSEnvironment` from one of two sources, in priority order:
- *
- *   1. **Environment variables** — used when `AWS_ACCESS_KEY_ID` is set, as
- *      it is on GitHub Actions runners after `aws-actions/configure-aws-credentials`
- *      runs (OIDC), or whenever the user has exported static creds. Requires
- *      `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`, and `AWS_ACCOUNT_ID`. The role
- *      ARN's account ID is exported by `configure-aws-credentials` as
- *      `AWS_ACCOUNT_ID` when invoked with `output-credentials: true`.
- *   2. **SSO profile** (`AWS_PROFILE`, default `"default"`) — used locally
- *      when no static creds are exported. Reads the profile's
- *      `sso_account_id` / `region` from `~/.aws/config` and refreshes
- *      credentials lazily via `aws sso login`.
- */
 export const Default = Layer.effect(
   AWSEnvironment,
-  Effect.suspend(() => loadDefault()),
-).pipe(Layer.orDie);
-
-export const loadDefault = () =>
   Effect.gen(function* () {
-    // Env-credentials path only kicks in under CI (where
-    // `aws-actions/configure-aws-credentials` exports AWS_ACCESS_KEY_ID
-    // and friends). Locally we always go through SSO so a stray
-    // AWS_ACCESS_KEY_ID in the shell doesn't silently override the
-    // user's `~/.aws/config` profile.
+    const profile = yield* AlchemyProfile;
+    const auth = yield* getAuthProvider<AwsAuthConfig, AwsResolvedCredentials>(
+      AWS_AUTH_PROVIDER_NAME,
+    );
+    const profileName = yield* ALCHEMY_PROFILE;
     const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-    if (ci) {
-      const accessKeyId = yield* AWS_ACCESS_KEY_ID.pipe(
-        Config.option,
-        Config.map(Option.getOrUndefined),
-      );
-      if (accessKeyId) {
-        return yield* loadFromEnv(accessKeyId);
-      }
-    }
-    return yield* loadFromSso();
-  });
 
-const loadFromEnv = (accessKeyId: string) =>
-  Effect.gen(function* () {
-    const secretAccessKey = yield* AWS_SECRET_ACCESS_KEY;
-    const sessionToken = yield* AWS_SESSION_TOKEN.pipe(
-      Config.option,
-      Config.map(Option.getOrUndefined),
+    return yield* profile.loadOrConfigure(auth, profileName, { ci }).pipe(
+      Effect.flatMap((config) => auth.read(profileName, config)),
+      Effect.orDie,
+      Effect.cached,
     );
-    const region = yield* AWS_REGION;
-    const accountId = yield* AWS_ACCOUNT_ID;
-    return {
-      accountId,
-      region,
-      credentials: Effect.succeed({
-        accessKeyId: Redacted.make(accessKeyId),
-        secretAccessKey,
-        sessionToken,
-      } satisfies ResolvedCredentials),
-    } satisfies AWSEnvironmentShape;
-  });
-
-const loadFromSso = () =>
-  Effect.gen(function* () {
-    const profileName = yield* AWS_PROFILE;
-    const auth = yield* Auth.Default;
-    const profile = yield* auth.loadProfile(profileName);
-    if (!profile.sso_account_id) {
-      return yield* Effect.die(
-        `AWS SSO profile '${profileName}' is missing sso_account_id`,
-      );
-    }
-    const region =
-      profile.region ??
-      (yield* AWS_REGION.pipe(
-        Config.option,
-        Config.map(Option.getOrElse(() => "us-east-1")),
-      ));
-    return {
-      profile: profileName,
-      accountId: profile.sso_account_id,
-      region,
-      credentials: auth.loadProfileCredentials(profileName),
-    } satisfies AWSEnvironmentShape;
-  });
-
-export interface AWSEnvironmentStaticInput {
-  accountId: AccountID;
-  region: RegionID;
-  credentials: AwsCredentialIdentity;
-  endpoint?: string;
-  profile?: string;
-}
-
-const isStatic = (
-  shape: AWSEnvironmentShape | AWSEnvironmentStaticInput,
-): shape is AWSEnvironmentStaticInput =>
-  shape.credentials != null &&
-  typeof (shape.credentials as AwsCredentialIdentity).accessKeyId === "string";
-
-/**
- * Build an `AWSEnvironment` Layer directly from values — useful for
- * static credentials in CI or tests.
- *
- * Named `makeEnvironment` rather than `of` because `Context.Service.of`
- * already exists with different semantics (builds the service value, not
- * a Layer); putting both on `AWSEnvironment` would be confusing.
- */
-export const makeEnvironment = (
-  shape: AWSEnvironmentShape | AWSEnvironmentStaticInput,
-) =>
-  Layer.succeed(
-    AWSEnvironment,
-    isStatic(shape)
-      ? {
-          ...shape,
-          credentials: Effect.succeed(
-            fromAwsCredentialIdentity(shape.credentials),
-          ),
-        }
-      : shape,
-  );
+  }),
+).pipe(Layer.orDie);

package/src/AWS/EventBridge/EventBus.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as eventbridge from "@distilled.cloud/aws/eventbridge";
 import * as Effect from "effect/Effect";
 
@@ -7,7 +6,6 @@ import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import {
   createInternalTags,
   createTagsList,
@@ -15,6 +13,7 @@ import {
   hasAlchemyTags,
 } from "../../Tags.ts";
 import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 import type { QueueArn } from "../SQS/Queue.ts";
 
@@ -121,9 +120,6 @@ export const EventBusProvider = () =>
   Provider.effect(
     EventBus,
     Effect.gen(function* () {
-      const region = yield* Region;
-      const { accountId } = yield* AWSEnvironment;
-
       const createEventBusName = (id: string, props: { name?: string } = {}) =>
         Effect.gen(function* () {
           if (props.name) {
@@ -178,6 +174,7 @@ export const EventBusProvider = () =>
             : Unowned(attrs);
         }),
         reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
+          const { accountId, region } = yield* AWSEnvironment.current;
           const eventBusName =
             output?.eventBusName ?? (yield* createEventBusName(id, news));
           const eventBusArn = (output?.eventBusArn ??

package/src/AWS/EventBridge/ListRules.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as eventbridge from "@distilled.cloud/aws/eventbridge";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -32,7 +31,6 @@ export const ListRulesLive = Layer.effect(
   Effect.gen(function* () {
     const Policy = yield* ListRulesPolicy;
     const listRules = yield* eventbridge.listRules;
-
     return Effect.fn(function* (bus?: EventBus) {
       const EventBusName = bus ? yield* bus.eventBusName : undefined;
       yield* Policy(bus);
@@ -57,10 +55,9 @@ export class ListRulesPolicy extends Binding.Policy<
 
 export const ListRulesPolicyLive = ListRulesPolicy.layer.effect(
   Effect.gen(function* () {
-    const region = yield* Region;
-    const { accountId } = yield* AWSEnvironment;
-
+    const env = yield* AWSEnvironment;
     return Effect.fn(function* (host, bus?: EventBus) {
+      const { accountId, region } = yield* env;
       if (isFunction(host)) {
         const resource = bus
           ? Output.interpolate`${bus.eventBusArn}`