alchemy 2.0.0-beta.17 → 2.0.0-beta.18

package/src/AWS/CloudFront/ResponseHeadersPolicy.ts

@@ -0,0 +1,308 @@
+import * as cloudfront from "@distilled.cloud/aws/cloudfront";
+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";
+
+export interface ResponseHeadersPolicyProps {
+  /**
+   * Name of the response headers policy. If omitted, a deterministic name is
+   * generated. Names must be unique per AWS account. Changing the name
+   * triggers a replacement.
+   */
+  name?: string;
+  /**
+   * Optional comment describing the policy.
+   */
+  comment?: string;
+  /**
+   * CORS configuration applied to viewer responses.
+   */
+  corsConfig?: cloudfront.ResponseHeadersPolicyCorsConfig;
+  /**
+   * Standard security headers (HSTS, X-Frame-Options, etc.) added to
+   * viewer responses.
+   */
+  securityHeadersConfig?: cloudfront.ResponseHeadersPolicySecurityHeadersConfig;
+  /**
+   * Server-Timing header configuration for measuring CloudFront performance.
+   */
+  serverTimingHeadersConfig?: cloudfront.ResponseHeadersPolicyServerTimingHeadersConfig;
+  /**
+   * Custom headers to add to viewer responses.
+   */
+  customHeadersConfig?: cloudfront.ResponseHeadersPolicyCustomHeadersConfig;
+  /**
+   * Headers to remove from viewer responses.
+   */
+  removeHeadersConfig?: cloudfront.ResponseHeadersPolicyRemoveHeadersConfig;
+}
+
+export interface ResponseHeadersPolicy extends Resource<
+  "AWS.CloudFront.ResponseHeadersPolicy",
+  ResponseHeadersPolicyProps,
+  {
+    /**
+     * CloudFront-assigned response headers policy identifier.
+     */
+    responseHeadersPolicyId: string;
+    /**
+     * Name of the response headers policy.
+     */
+    name: string;
+    /**
+     * Most recent entity tag for update/delete operations.
+     */
+    etag: string | undefined;
+    /**
+     * Current comment on the policy.
+     */
+    comment: string | undefined;
+    /**
+     * Current CORS configuration.
+     */
+    corsConfig: cloudfront.ResponseHeadersPolicyCorsConfig | undefined;
+    /**
+     * Current security headers configuration.
+     */
+    securityHeadersConfig:
+      | cloudfront.ResponseHeadersPolicySecurityHeadersConfig
+      | undefined;
+    /**
+     * Current Server-Timing configuration.
+     */
+    serverTimingHeadersConfig:
+      | cloudfront.ResponseHeadersPolicyServerTimingHeadersConfig
+      | undefined;
+    /**
+     * Current custom headers configuration.
+     */
+    customHeadersConfig:
+      | cloudfront.ResponseHeadersPolicyCustomHeadersConfig
+      | undefined;
+    /**
+     * Current remove-headers configuration.
+     */
+    removeHeadersConfig:
+      | cloudfront.ResponseHeadersPolicyRemoveHeadersConfig
+      | undefined;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * A CloudFront response headers policy.
+ *
+ * Response headers policies add or remove headers in viewer responses,
+ * including CORS, standard security headers (HSTS, X-Frame-Options,
+ * X-Content-Type-Options, Referrer-Policy, etc.), Server-Timing, custom
+ * headers and explicit header removal. They are referenced by ID on a
+ * Distribution's default behavior or per-path cache behaviors.
+ *
+ * @section Creating Response Headers Policies
+ * @example Standard security + CORS
+ * ```typescript
+ * const responseHeadersPolicy = yield* ResponseHeadersPolicy("AppResponseHeaders", {
+ *   comment: "Default app security + CORS",
+ *   corsConfig: {
+ *     AccessControlAllowOrigins: { Quantity: 1, Items: ["https://app.example.com"] },
+ *     AccessControlAllowMethods: { Quantity: 2, Items: ["GET", "OPTIONS"] },
+ *     AccessControlAllowHeaders: { Quantity: 1, Items: ["Authorization"] },
+ *     AccessControlAllowCredentials: false,
+ *     OriginOverride: true,
+ *   },
+ *   securityHeadersConfig: {
+ *     StrictTransportSecurity: {
+ *       AccessControlMaxAgeSec: 31536000,
+ *       IncludeSubdomains: true,
+ *       Preload: true,
+ *       Override: true,
+ *     },
+ *     ContentTypeOptions: { Override: true },
+ *     FrameOptions: { FrameOption: "DENY", Override: true },
+ *     ReferrerPolicy: { ReferrerPolicy: "no-referrer", Override: true },
+ *   },
+ * });
+ * ```
+ */
+export const ResponseHeadersPolicy = Resource<ResponseHeadersPolicy>(
+  "AWS.CloudFront.ResponseHeadersPolicy",
+);
+
+export const ResponseHeadersPolicyProvider = () =>
+  Provider.effect(
+    ResponseHeadersPolicy,
+    Effect.gen(function* () {
+      const getById = Effect.fn(function* (id: string) {
+        const config = yield* cloudfront
+          .getResponseHeadersPolicyConfig({ Id: id })
+          .pipe(
+            Effect.catchTag("NoSuchResponseHeadersPolicy", () =>
+              Effect.succeed(undefined),
+            ),
+          );
+        if (!config?.ResponseHeadersPolicyConfig) return undefined;
+        return {
+          config: config.ResponseHeadersPolicyConfig,
+          etag: config.ETag,
+        };
+      });
+
+      const getByName = Effect.fn(function* (name: string) {
+        const listed = yield* cloudfront.listResponseHeadersPolicies({
+          Type: "custom",
+        });
+        const summary = listed.ResponseHeadersPolicyList?.Items?.find(
+          (item) =>
+            item.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.Name ===
+            name,
+        );
+        if (!summary?.ResponseHeadersPolicy?.Id) return undefined;
+        return yield* getById(summary.ResponseHeadersPolicy.Id).pipe(
+          Effect.map((found) =>
+            found
+              ? { id: summary.ResponseHeadersPolicy.Id, ...found }
+              : undefined,
+          ),
+        );
+      });
+
+      const buildConfig = (
+        name: string,
+        props: ResponseHeadersPolicyProps,
+      ): cloudfront.ResponseHeadersPolicyConfig => ({
+        Name: name,
+        Comment: props.comment,
+        CorsConfig: props.corsConfig,
+        SecurityHeadersConfig: props.securityHeadersConfig,
+        ServerTimingHeadersConfig: props.serverTimingHeadersConfig,
+        CustomHeadersConfig: props.customHeadersConfig,
+        RemoveHeadersConfig: props.removeHeadersConfig,
+      });
+
+      const toAttrs = (
+        id: string,
+        config: cloudfront.ResponseHeadersPolicyConfig,
+        etag: string | undefined,
+      ) => ({
+        responseHeadersPolicyId: id,
+        name: config.Name,
+        etag,
+        comment: config.Comment,
+        corsConfig: config.CorsConfig,
+        securityHeadersConfig: config.SecurityHeadersConfig,
+        serverTimingHeadersConfig: config.ServerTimingHeadersConfig,
+        customHeadersConfig: config.CustomHeadersConfig,
+        removeHeadersConfig: config.RemoveHeadersConfig,
+      });
+
+      return {
+        stables: ["responseHeadersPolicyId"],
+        diff: Effect.fn(function* ({ id, news, olds }) {
+          if (!isResolved(news)) return undefined;
+          if (
+            (yield* createName(id, olds ?? {})) !==
+            (yield* createName(id, news))
+          ) {
+            return { action: "replace" } as const;
+          }
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          if (output?.responseHeadersPolicyId) {
+            const found = yield* getById(output.responseHeadersPolicyId);
+            if (found) {
+              return toAttrs(
+                output.responseHeadersPolicyId,
+                found.config,
+                found.etag,
+              );
+            }
+          }
+          const name = yield* createName(id, olds ?? {});
+          const found = yield* getByName(name);
+          if (!found) return undefined;
+          return toAttrs(found.id, found.config, found.etag);
+        }),
+        create: Effect.fn(function* ({ id, news, session }) {
+          const name = yield* createName(id, news);
+          const created = yield* cloudfront
+            .createResponseHeadersPolicy({
+              ResponseHeadersPolicyConfig: buildConfig(name, news),
+            })
+            .pipe(
+              Effect.catchTag("ResponseHeadersPolicyAlreadyExists", () =>
+                getByName(name).pipe(
+                  Effect.flatMap((existing) =>
+                    existing
+                      ? Effect.succeed({
+                          ResponseHeadersPolicy: {
+                            Id: existing.id,
+                            LastModifiedTime: new Date(),
+                            ResponseHeadersPolicyConfig: existing.config,
+                          },
+                          ETag: existing.etag,
+                          Location: undefined,
+                        })
+                      : Effect.fail(
+                          new Error(
+                            `Response headers policy '${name}' already exists but could not be recovered`,
+                          ),
+                        ),
+                  ),
+                ),
+              ),
+            );
+          if (!created.ResponseHeadersPolicy?.Id) {
+            return yield* Effect.fail(
+              new Error("createResponseHeadersPolicy returned no identifier"),
+            );
+          }
+          yield* session.note(created.ResponseHeadersPolicy.Id);
+          return toAttrs(
+            created.ResponseHeadersPolicy.Id,
+            created.ResponseHeadersPolicy.ResponseHeadersPolicyConfig,
+            created.ETag,
+          );
+        }),
+        update: Effect.fn(function* ({ news, output, session }) {
+          const current = yield* getById(output.responseHeadersPolicyId);
+          const updated = yield* cloudfront.updateResponseHeadersPolicy({
+            Id: output.responseHeadersPolicyId,
+            IfMatch: current?.etag ?? output.etag,
+            ResponseHeadersPolicyConfig: buildConfig(output.name, news),
+          });
+          if (!updated.ResponseHeadersPolicy?.Id) {
+            return yield* Effect.fail(
+              new Error("updateResponseHeadersPolicy returned no identifier"),
+            );
+          }
+          yield* session.note(output.responseHeadersPolicyId);
+          return toAttrs(
+            updated.ResponseHeadersPolicy.Id,
+            updated.ResponseHeadersPolicy.ResponseHeadersPolicyConfig,
+            updated.ETag,
+          );
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          const current = yield* getById(output.responseHeadersPolicyId);
+          if (!current) return;
+          yield* cloudfront
+            .deleteResponseHeadersPolicy({
+              Id: output.responseHeadersPolicyId,
+              IfMatch: current.etag,
+            })
+            .pipe(
+              Effect.catchTag("NoSuchResponseHeadersPolicy", () => Effect.void),
+            );
+        }),
+      };
+    }),
+  );
+
+const createName = (id: string, props: ResponseHeadersPolicyProps) =>
+  props.name
+    ? Effect.succeed(props.name)
+    : createPhysicalName({ id, maxLength: 128, lowercase: true });

package/src/AWS/CloudFront/index.ts

@@ -1,6 +1,8 @@
+export { CachePolicy, CachePolicyProvider } from "./CachePolicy.ts";
 export { Distribution, DistributionProvider } from "./Distribution.ts";
 export { Function, FunctionProvider } from "./Function.ts";
 export { Invalidation, InvalidationProvider } from "./Invalidation.ts";
+export { KeyGroup, KeyGroupProvider } from "./KeyGroup.ts";
 export { KeyValueStore, KeyValueStoreProvider } from "./KeyValueStore.ts";
 export { KvEntries, KvEntriesProvider } from "./KvEntries.ts";
 export { KvRoutesUpdate, KvRoutesUpdateProvider } from "./KvRoutesUpdate.ts";
@@ -13,3 +15,12 @@ export {
   OriginAccessControl,
   OriginAccessControlProvider,
 } from "./OriginAccessControl.ts";
+export {
+  OriginRequestPolicy,
+  OriginRequestPolicyProvider,
+} from "./OriginRequestPolicy.ts";
+export { PublicKey, PublicKeyProvider } from "./PublicKey.ts";
+export {
+  ResponseHeadersPolicy,
+  ResponseHeadersPolicyProvider,
+} from "./ResponseHeadersPolicy.ts";

package/src/AWS/ECS/CapacityProvider.ts

@@ -0,0 +1,336 @@
+import * as ecs from "@distilled.cloud/aws/ecs";
+import { Region } from "@distilled.cloud/aws/Region";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AdoptPolicy } from "../../AdoptPolicy.ts";
+import { isResolved } from "../../Diff.ts";
+import type { Input } from "../../Input.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { createInternalTags, diffTags, hasTags } from "../../Tags.ts";
+import { AWSEnvironment, type AccountID } from "../Environment.ts";
+import type { Providers } from "../Providers.ts";
+import type { RegionID } from "../Region.ts";
+
+export type CapacityProviderName = string;
+export type CapacityProviderArn =
+  `arn:aws:ecs:${RegionID}:${AccountID}:capacity-provider/${CapacityProviderName}`;
+
+export interface CapacityProviderProps {
+  /**
+   * Capacity provider name. If omitted, a deterministic name is generated.
+   *
+   * Names beginning with `aws`, `ecs`, or `fargate` are reserved by AWS.
+   * Changing this triggers a replacement.
+   */
+  name?: string;
+  /**
+   * ARN of the EC2 Auto Scaling Group that backs this capacity provider.
+   *
+   * Cannot be changed after creation; changing this triggers a replacement.
+   */
+  autoScalingGroupArn: Input<string>;
+  /**
+   * Managed scaling configuration applied by ECS to the underlying ASG.
+   */
+  managedScaling?: ecs.ManagedScaling;
+  /**
+   * Whether ECS protects in-use container instances from ASG scale-in.
+   * @default "DISABLED"
+   */
+  managedTerminationProtection?: ecs.ManagedTerminationProtection;
+  /**
+   * Whether ECS sets container instances to DRAINING when terminated by ASG.
+   * @default "DISABLED"
+   */
+  managedDraining?: ecs.ManagedDraining;
+  /**
+   * User-defined tags to apply to the capacity provider.
+   */
+  tags?: Record<string, string>;
+}
+
+export interface CapacityProvider extends Resource<
+  "AWS.ECS.CapacityProvider",
+  CapacityProviderProps,
+  {
+    capacityProviderArn: CapacityProviderArn;
+    name: CapacityProviderName;
+    status: ecs.CapacityProviderStatus;
+    updateStatus: ecs.CapacityProviderUpdateStatus | undefined;
+    autoScalingGroupArn: string;
+    managedScaling: ecs.ManagedScaling | undefined;
+    managedTerminationProtection: ecs.ManagedTerminationProtection | undefined;
+    managedDraining: ecs.ManagedDraining | undefined;
+    tags: Record<string, string>;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * An Amazon ECS capacity provider backed by an EC2 Auto Scaling Group.
+ *
+ * Capacity providers are associated with one or more ECS clusters via
+ * {@link Cluster#capacityProviders} and are referenced by a service or task's
+ * capacity provider strategy.
+ *
+ * Only EC2 Auto Scaling Group-backed capacity providers are currently
+ * supported. The reserved AWS providers `FARGATE` and `FARGATE_SPOT` do not
+ * need to be created and can be referenced by name on a `Cluster` directly.
+ *
+ * @section Creating Capacity Providers
+ * @example ASG-Backed Capacity Provider
+ * ```typescript
+ * const provider = yield* CapacityProvider("AppCapacityProvider", {
+ *   autoScalingGroupArn: asg.autoScalingGroupArn,
+ *   managedScaling: {
+ *     status: "ENABLED",
+ *     targetCapacity: 80,
+ *     minimumScalingStepSize: 1,
+ *     maximumScalingStepSize: 10,
+ *   },
+ *   managedTerminationProtection: "ENABLED",
+ * });
+ *
+ * yield* Cluster("AppCluster", {
+ *   capacityProviders: [provider.name],
+ *   defaultCapacityProviderStrategy: [
+ *     { capacityProvider: provider.name, weight: 1 },
+ *   ],
+ * });
+ * ```
+ *
+ * @section Adopting Existing Capacity Providers
+ * @example Adopt an existing provider
+ * ```typescript
+ * import { adopt } from "alchemy/AdoptPolicy";
+ *
+ * yield* CapacityProvider("AppCapacityProvider", {
+ *   name: "existing-provider",
+ *   autoScalingGroupArn: asg.autoScalingGroupArn,
+ * }).pipe(adopt());
+ * ```
+ */
+export const CapacityProvider = Resource<CapacityProvider>(
+  "AWS.ECS.CapacityProvider",
+);
+
+export const CapacityProviderProvider = () =>
+  Provider.effect(
+    CapacityProvider,
+    Effect.gen(function* () {
+      const adoptPolicy = yield* Effect.serviceOption(AdoptPolicy).pipe(
+        Effect.map(Option.getOrElse(() => false)),
+      );
+
+      const toEcsTags = (tags: Record<string, string>): ecs.Tag[] =>
+        Object.entries(tags).map(([key, value]) => ({ key, value }));
+
+      const fromEcsTags = (tags: ecs.Tag[] | undefined): Record<string, string> =>
+        Object.fromEntries(
+          (tags ?? [])
+            .filter((t): t is { key: string; value: string } =>
+              t.key !== undefined && t.value !== undefined,
+            )
+            .map((t) => [t.key, t.value]),
+        );
+
+      const toName = (id: string, props: { name?: string } = {}) =>
+        props.name
+          ? Effect.succeed(props.name)
+          : createPhysicalName({ id, maxLength: 255, lowercase: true });
+
+      const describe = (name: string) =>
+        ecs
+          .describeCapacityProviders({
+            capacityProviders: [name],
+            include: ["TAGS"],
+          })
+          .pipe(
+            Effect.map((res) =>
+              res.capacityProviders?.find((p) => p.name === name),
+            ),
+          );
+
+      return {
+        stables: ["capacityProviderArn", "name"],
+
+        diff: Effect.fn(function* ({ id, news, olds }) {
+          if (!isResolved(news)) return;
+          const oldName = yield* toName(id, olds ?? {});
+          const newName = yield* toName(id, news);
+          if (oldName !== newName) {
+            return { action: "replace" } as const;
+          }
+          if (
+            isResolved(olds.autoScalingGroupArn) &&
+            olds.autoScalingGroupArn !== news.autoScalingGroupArn
+          ) {
+            return { action: "replace" } as const;
+          }
+        }),
+
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const name = output?.name ?? (yield* toName(id, olds ?? {}));
+          const found = yield* describe(name);
+          if (!found?.name || !found.capacityProviderArn) {
+            return undefined;
+          }
+          return {
+            capacityProviderArn:
+              found.capacityProviderArn as CapacityProviderArn,
+            name: found.name,
+            status: (found.status ?? "ACTIVE") as ecs.CapacityProviderStatus,
+            updateStatus: found.updateStatus,
+            autoScalingGroupArn:
+              found.autoScalingGroupProvider?.autoScalingGroupArn ?? "",
+            managedScaling: found.autoScalingGroupProvider?.managedScaling,
+            managedTerminationProtection:
+              found.autoScalingGroupProvider?.managedTerminationProtection,
+            managedDraining: found.autoScalingGroupProvider?.managedDraining,
+            tags: fromEcsTags(found.tags),
+          };
+        }),
+
+        create: Effect.fn(function* ({ id, news, session }) {
+          const region = yield* Region;
+          const { accountId } = yield* AWSEnvironment;
+          const name = yield* toName(id, news);
+          const internalTags = yield* createInternalTags(id);
+          const tags = { ...internalTags, ...news.tags };
+
+          const existing = yield* describe(name);
+          if (existing?.name && existing.capacityProviderArn) {
+            // The provider already exists. Only adopt when AdoptPolicy is true.
+            if (!adoptPolicy) {
+              return yield* Effect.die(
+                new Error(
+                  `ECS capacity provider "${name}" already exists. ` +
+                    `Provide adopt() on the resource or stack to adopt it.`,
+                ),
+              );
+            }
+            yield* session.note(
+              `Adopting existing ECS capacity provider ${name}`,
+            );
+
+            // If we own it (tags match), leave tags as-is. Otherwise apply
+            // our internal tags so future operations can identify ownership.
+            if (!hasTags(internalTags, fromEcsTags(existing.tags))) {
+              yield* ecs.tagResource({
+                resourceArn: existing.capacityProviderArn,
+                tags: toEcsTags(tags),
+              });
+            }
+
+            return {
+              capacityProviderArn:
+                existing.capacityProviderArn as CapacityProviderArn,
+              name: existing.name,
+              status: (existing.status ??
+                "ACTIVE") as ecs.CapacityProviderStatus,
+              updateStatus: existing.updateStatus,
+              autoScalingGroupArn:
+                existing.autoScalingGroupProvider?.autoScalingGroupArn ?? "",
+              managedScaling:
+                existing.autoScalingGroupProvider?.managedScaling,
+              managedTerminationProtection:
+                existing.autoScalingGroupProvider
+                  ?.managedTerminationProtection,
+              managedDraining:
+                existing.autoScalingGroupProvider?.managedDraining,
+              tags: { ...fromEcsTags(existing.tags), ...tags },
+            };
+          }
+
+          const autoScalingGroupArn = news.autoScalingGroupArn as string;
+          const created = yield* ecs.createCapacityProvider({
+            name,
+            autoScalingGroupProvider: {
+              autoScalingGroupArn,
+              managedScaling: news.managedScaling,
+              managedTerminationProtection: news.managedTerminationProtection,
+              managedDraining: news.managedDraining,
+            },
+            tags: toEcsTags(tags),
+          });
+
+          const provider = created.capacityProvider;
+          const capacityProviderArn = (provider?.capacityProviderArn ??
+            `arn:aws:ecs:${region}:${accountId}:capacity-provider/${name}`) as CapacityProviderArn;
+          yield* session.note(capacityProviderArn);
+
+          return {
+            capacityProviderArn,
+            name,
+            status: (provider?.status ?? "ACTIVE") as ecs.CapacityProviderStatus,
+            updateStatus: provider?.updateStatus,
+            autoScalingGroupArn,
+            managedScaling: news.managedScaling,
+            managedTerminationProtection: news.managedTerminationProtection,
+            managedDraining: news.managedDraining,
+            tags,
+          };
+        }),
+
+        update: Effect.fn(function* ({ id, news, olds, output, session }) {
+          const internalTags = yield* createInternalTags(id);
+          const newTags = { ...internalTags, ...news.tags };
+          const oldTags = { ...internalTags, ...olds.tags };
+
+          yield* ecs.updateCapacityProvider({
+            name: output.name,
+            autoScalingGroupProvider: {
+              managedScaling: news.managedScaling,
+              managedTerminationProtection: news.managedTerminationProtection,
+              managedDraining: news.managedDraining,
+            },
+          });
+
+          const { removed, upsert } = diffTags(oldTags, newTags);
+          if (upsert.length > 0) {
+            yield* ecs.tagResource({
+              resourceArn: output.capacityProviderArn,
+              tags: upsert.map((t) => ({ key: t.Key, value: t.Value })),
+            });
+          }
+          if (removed.length > 0) {
+            yield* ecs.untagResource({
+              resourceArn: output.capacityProviderArn,
+              tagKeys: removed,
+            });
+          }
+
+          const found = yield* describe(output.name);
+          yield* session.note(output.capacityProviderArn);
+          return {
+            ...output,
+            status: (found?.status ?? output.status) as ecs.CapacityProviderStatus,
+            updateStatus: found?.updateStatus ?? output.updateStatus,
+            managedScaling:
+              found?.autoScalingGroupProvider?.managedScaling ??
+              news.managedScaling,
+            managedTerminationProtection:
+              found?.autoScalingGroupProvider?.managedTerminationProtection ??
+              news.managedTerminationProtection,
+            managedDraining:
+              found?.autoScalingGroupProvider?.managedDraining ??
+              news.managedDraining,
+            tags: newTags,
+          };
+        }),
+
+        delete: Effect.fn(function* ({ output }) {
+          yield* ecs
+            .deleteCapacityProvider({ capacityProvider: output.name })
+            .pipe(
+              // Already gone — treat as success.
+              Effect.catchTag("InvalidParameterException", () => Effect.void),
+              Effect.catchTag("ClientException", () => Effect.void),
+            );
+        }),
+      };
+    }),
+  );

package/src/AWS/ECS/index.ts

@@ -1,3 +1,7 @@
+export {
+  CapacityProvider,
+  CapacityProviderProvider,
+} from "./CapacityProvider.ts";
 export { Cluster, ClusterProvider } from "./Cluster.ts";
 export {
   DescribeTasks,