alchemy 2.0.0-beta.55 → 2.0.0-beta.56

package/src/AWS/ACM/Certificate.ts

@@ -3,6 +3,7 @@ import * as acm from "@distilled.cloud/aws/acm";
 import * as route53 from "@distilled.cloud/aws/route-53";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
@@ -307,6 +308,53 @@ export const CertificateProvider = () =>
 
       return {
         stables: ["certificateArn"],
+        list: () =>
+          Effect.gen(function* () {
+            // ACM certificates for CloudFront live in us-east-1; enumerate
+            // every certificate in the ambient account/region, then hydrate
+            // each to the full Attributes shape via describe + list tags.
+            const summaries = yield* withAcmRegion(
+              acm.listCertificates.pages({}).pipe(
+                Stream.runCollect,
+                Effect.map((chunk) =>
+                  Array.from(chunk).flatMap(
+                    (page) => page.CertificateSummaryList ?? [],
+                  ),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              summaries,
+              (summary) =>
+                Effect.gen(function* () {
+                  if (!summary.CertificateArn) {
+                    return undefined;
+                  }
+                  const detail = yield* describeCertificate(
+                    summary.CertificateArn,
+                  );
+                  if (!detail?.CertificateArn) {
+                    return undefined;
+                  }
+                  const tags = yield* listCertificateTags(
+                    detail.CertificateArn,
+                  );
+                  return toAttrs(
+                    {
+                      domainName: detail.DomainName ?? "",
+                      validationMethod:
+                        detail.DomainValidationOptions?.[0]?.ValidationMethod,
+                    },
+                    detail,
+                    tags,
+                  );
+                }),
+              { concurrency: 10 },
+            );
+            return rows.filter(
+              (row): row is ReturnType<typeof toAttrs> => row !== undefined,
+            );
+          }),
         diff: Effect.fn(function* ({ olds, news: _news }) {
           if (!isResolved(_news)) return undefined;
           const news = _news as typeof olds;
@@ -468,7 +516,10 @@ const ACM_REGION = "us-east-1" as const;
 const defaultValidationMethod = "DNS" as const;
 
 const withAcmRegion = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  effect.pipe(Effect.provideService(AwsRegion, ACM_REGION as any));
+  // `AwsRegion`'s service value is an `Effect<RegionName>` (see
+  // `@distilled.cloud/aws/Region`), so it must be provided as an effect, not a
+  // bare string — providing a raw string yields a primitive into the run loop.
+  effect.pipe(Effect.provideService(AwsRegion, Effect.succeed(ACM_REGION)));
 
 const normalizeHostedZoneId = (hostedZoneId: string) =>
   hostedZoneId.replace(/^\/hostedzone\//, "");

package/src/AWS/ApiGateway/Account.ts

@@ -1,7 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import { isResolved } from "../../Diff.ts";
-import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import type { Providers } from "../Providers.ts";
@@ -76,6 +75,19 @@ export const AccountProvider = () =>
             managesCloudwatchRoleArn: output?.managesCloudwatchRoleArn ?? false,
           };
         }),
+        // Account settings are an account/region singleton — there is no
+        // collection API, only `getAccount`. Return the single instance as a
+        // one-element array (account singleton pattern).
+        list: () =>
+          ag.getAccount({}).pipe(
+            Effect.map((a) => [
+              {
+                cloudwatchRoleArn: a.cloudwatchRoleArn,
+                managesCloudwatchRoleArn: false,
+              },
+            ]),
+            Effect.catchTag("NotFoundException", () => Effect.succeed([])),
+          ),
         reconcile: Effect.fn(function* ({ news: newsIn, session }) {
           if (!isResolved(newsIn)) {
             return yield* Effect.die("Account props were not resolved");

package/src/AWS/ApiGateway/ApiKey.ts

@@ -141,6 +141,22 @@ export const ApiKeyProvider = () =>
             tags: tagRecord(k.tags),
           };
         }),
+        list: () =>
+          ag.getApiKeys.pages({ limit: 500, includeValues: false }).pipe(
+            Stream.runCollect,
+            Effect.map((chunk) =>
+              Array.from(chunk).flatMap((page) =>
+                (page.items ?? [])
+                  .filter((k): k is ag.ApiKey & { id: string } => !!k.id)
+                  .map((k) => ({
+                    id: k.id,
+                    name: k.name,
+                    enabled: k.enabled,
+                    tags: tagRecord(k.tags),
+                  })),
+              ),
+            ),
+          ),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
           const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {

package/src/AWS/ApiGateway/Authorizer.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
@@ -260,6 +261,43 @@ export const AuthorizerProvider = () =>
             type: final.type!,
           };
         }),
+        // Authorizers are sub-resources of a RestApi and can only be listed
+        // per-parent (`GET /restapis/{restApiId}/authorizers`). Enumerate every
+        // RestApi (paginated), then fan out the per-api authorizer list.
+        list: () =>
+          Effect.gen(function* () {
+            const restApiIds = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? [])
+                    .map((api) => api.id)
+                    .filter((id): id is string => id != null),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              restApiIds,
+              (restApiId) =>
+                ag.getAuthorizers({ restApiId }).pipe(
+                  Effect.map((res) =>
+                    (res.items ?? [])
+                      .filter(
+                        (a): a is ag.Authorizer & { id: string } =>
+                          a.id != null,
+                      )
+                      .map((a) => ({
+                        authorizerId: a.id,
+                        restApiId,
+                        name: a.name!,
+                        type: a.type!,
+                      })),
+                  ),
+                ),
+              { concurrency: 10 },
+            );
+            return rows.flat();
+          }),
         delete: Effect.fn(function* ({ output, session }) {
           yield* ag
             .deleteAuthorizer({

package/src/AWS/ApiGateway/BasePathMapping.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
@@ -175,6 +176,69 @@ export const BasePathMappingProvider = () =>
             stage: final.stage,
           };
         }),
+        // BasePathMappings are sub-resources keyed by their parent domain
+        // name. There is no account-wide list, so enumerate every custom
+        // domain name first (getDomainNames) and then list the mappings under
+        // each (getBasePathMappings), flattening to the full Attributes shape.
+        list: () =>
+          Effect.gen(function* () {
+            const domains = yield* ag.getDomainNames.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? []).filter(
+                    (d): d is ag.DomainName & { domainName: string } =>
+                      d.domainName != null,
+                  ),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              domains,
+              (domain) =>
+                ag.getBasePathMappings
+                  .pages({
+                    domainName: domain.domainName,
+                    domainNameId: domain.domainNameId,
+                  })
+                  .pipe(
+                    Stream.runCollect,
+                    Effect.map((chunk) =>
+                      Array.from(chunk).flatMap((page) =>
+                        (page.items ?? [])
+                          .filter(
+                            (
+                              m,
+                            ): m is ag.BasePathMapping & {
+                              restApiId: string;
+                            } => m.restApiId != null,
+                          )
+                          .map((m) => ({
+                            domainName: domain.domainName,
+                            domainNameId: domain.domainNameId,
+                            basePath: normalizeBasePath(m.basePath),
+                            restApiId: m.restApiId,
+                            stage: m.stage,
+                          })),
+                      ),
+                    ),
+                    // A domain can disappear between enumeration and listing.
+                    Effect.catchTag("NotFoundException", () =>
+                      Effect.succeed(
+                        [] as {
+                          domainName: string;
+                          domainNameId: string | undefined;
+                          basePath: string;
+                          restApiId: string;
+                          stage: string | undefined;
+                        }[],
+                      ),
+                    ),
+                  ),
+              { concurrency: 10 },
+            );
+            return rows.flat();
+          }),
         delete: Effect.fn(function* ({ output, session }) {
           yield* ag
             .deleteBasePathMapping({

package/src/AWS/ApiGateway/Deployment.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { createHash } from "node:crypto";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
@@ -155,7 +156,7 @@ export const Deployment = (id: string, props: DeploymentInputProps) =>
       for (const b of bindings) {
         autoTriggers[`@alchemy:binding:${b.sid}`] = bindingDigest(b.data);
       }
-      triggers = { ...autoTriggers, ...(triggers ?? {}) };
+      triggers = { ...autoTriggers, ...triggers };
     }
     return yield* DeploymentResource(id, {
       ...rest,
@@ -205,6 +206,45 @@ export const DeploymentProvider = () =>
     Effect.gen(function* () {
       return {
         stables: ["deploymentId", "restApiId"] as const,
+        // Deployments are sub-resources keyed by `restApiId`. Enumerate every
+        // RestApi in the account/region, then page every deployment under each
+        // one and flatten — yielding the same Attributes shape `read` returns.
+        list: () =>
+          Effect.gen(function* () {
+            const restApiIds = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? [])
+                    .map((api) => api.id)
+                    .filter((id): id is string => id != null),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              restApiIds,
+              (restApiId) =>
+                ag.getDeployments.pages({ restApiId }).pipe(
+                  Stream.runCollect,
+                  Effect.map((chunk) =>
+                    Array.from(chunk).flatMap((page) =>
+                      (page.items ?? [])
+                        .filter(
+                          (d): d is ag.Deployment & { id: string } =>
+                            d.id != null,
+                        )
+                        .map((d) => ({
+                          deploymentId: d.id,
+                          restApiId,
+                          description: d.description,
+                        })),
+                    ),
+                  ),
+                ),
+              { concurrency: 10 },
+            );
+            return rows.flat();
+          }),
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
           if (!isResolved(newsIn)) return;
           const news = newsIn as Input.ResolveProps<DeploymentProps>;

package/src/AWS/ApiGateway/DomainName.ts

@@ -1,6 +1,7 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
@@ -125,6 +126,28 @@ export const DomainNameProvider = () =>
             return { action: "replace" } as const;
           }
         }),
+        list: () =>
+          ag.getDomainNames.pages({}).pipe(
+            Stream.runCollect,
+            Effect.map((chunk) =>
+              Array.from(chunk).flatMap((page) =>
+                (page.items ?? [])
+                  .filter(
+                    (d): d is ag.DomainName & { domainName: string } =>
+                      d.domainName != null,
+                  )
+                  .map((d) => ({
+                    domainName: d.domainName,
+                    regionalDomainName: d.regionalDomainName,
+                    regionalHostedZoneId: d.regionalHostedZoneId,
+                    distributionDomainName: d.distributionDomainName,
+                    distributionHostedZoneId: d.distributionHostedZoneId,
+                    domainNameArn: d.domainNameArn,
+                    tags: tagRecord(d.tags),
+                  })),
+              ),
+            ),
+          ),
         read: Effect.fn(function* ({ output }) {
           if (!output?.domainName) return undefined;
           const d = yield* ag

package/src/AWS/ApiGateway/GatewayResource.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
@@ -139,6 +140,52 @@ export const ResourceProvider = () =>
             return { action: "replace" } as const;
           }
         }),
+        list: () =>
+          Effect.gen(function* () {
+            // Enumerate parent RestApis, then list the resources under each.
+            const apiIds = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? [])
+                    .filter((api) => api.id != null)
+                    .map((api) => api.id!),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              apiIds,
+              (restApiId) =>
+                ag.getResources.pages({ restApiId }).pipe(
+                  Stream.runCollect,
+                  Effect.map((chunk) =>
+                    Array.from(chunk).flatMap((page) =>
+                      (page.items ?? [])
+                        // The API root resource ("/") has no parentId/pathPart;
+                        // it isn't a managed `Resource`, so skip it.
+                        .filter(
+                          (r) =>
+                            r.id != null &&
+                            r.parentId != null &&
+                            r.pathPart != null,
+                        )
+                        .map((r) => ({
+                          resourceId: r.id!,
+                          restApiId,
+                          parentId: r.parentId!,
+                          pathPart: r.pathPart!,
+                        })),
+                    ),
+                  ),
+                  // A RestApi can vanish mid-enumeration; skip it.
+                  Effect.catchTag("NotFoundException", () =>
+                    Effect.succeed([]),
+                  ),
+                ),
+              { concurrency: 10 },
+            );
+            return rows.flat();
+          }),
         read: Effect.fn(function* ({ output }) {
           if (!output?.resourceId) return undefined;
           const r = yield* ag

package/src/AWS/ApiGateway/GatewayResponse.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
@@ -81,6 +82,47 @@ export const GatewayResponseProvider = () =>
             statusCode: g.statusCode,
           };
         }),
+        // GatewayResponses are sub-resources of a RestApi, so enumerate every
+        // RestApi first (paginated), then list the gateway responses per api.
+        list: () =>
+          Effect.gen(function* () {
+            const restApiIds = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? [])
+                    .map((a) => a.id)
+                    .filter((id): id is string => id != null),
+                ),
+              ),
+            );
+            const rows = yield* Effect.forEach(
+              restApiIds,
+              (restApiId) =>
+                ag.getGatewayResponses({ restApiId }).pipe(
+                  Effect.map((res) =>
+                    (res.items ?? [])
+                      .filter(
+                        (
+                          g,
+                        ): g is ag.GatewayResponse & {
+                          responseType: ag.GatewayResponseType;
+                        } => g.responseType != null,
+                      )
+                      .map((g) => ({
+                        restApiId,
+                        responseType: g.responseType,
+                        statusCode: g.statusCode,
+                      })),
+                  ),
+                  Effect.catchTag("NotFoundException", () =>
+                    Effect.succeed([]),
+                  ),
+                ),
+              { concurrency: 10 },
+            );
+            return rows.flat();
+          }),
         reconcile: Effect.fn(function* ({ news: newsIn, output, session }) {
           if (!isResolved(newsIn)) {
             return yield* Effect.die("GatewayResponse props were not resolved");

package/src/AWS/ApiGateway/Method.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
@@ -384,6 +385,69 @@ export const MethodProvider = () =>
             httpMethod: output.httpMethod,
           });
         }),
+        // Methods are sub-resources keyed by (restApiId, resourceId,
+        // httpMethod) with no dedicated list-methods API. Enumerate every
+        // RestApi -> each Resource (embedding its method verbs) -> read each
+        // method snapshot so every item matches the exact `read` Attributes
+        // shape (including integration), directly usable by `delete`.
+        list: () =>
+          Effect.gen(function* () {
+            const restApis = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? []).filter(
+                    (api): api is ag.RestApi & { id: string } => api.id != null,
+                  ),
+                ),
+              ),
+            );
+
+            const perApi = yield* Effect.forEach(
+              restApis,
+              (api) =>
+                Effect.gen(function* () {
+                  const resources = yield* ag.getResources
+                    .pages({ restApiId: api.id, embed: ["methods"] })
+                    .pipe(
+                      Stream.runCollect,
+                      Effect.map((chunk) =>
+                        Array.from(chunk).flatMap((page) => page.items ?? []),
+                      ),
+                    );
+
+                  const keys = resources.flatMap((resource) =>
+                    resource.id
+                      ? Object.keys(resource.resourceMethods ?? {}).map(
+                          (httpMethod) => ({
+                            resourceId: resource.id as string,
+                            httpMethod,
+                          }),
+                        )
+                      : [],
+                  );
+
+                  const snaps = yield* Effect.forEach(
+                    keys,
+                    (key) =>
+                      readMethodSnapshot({
+                        restApiId: api.id,
+                        resourceId: key.resourceId,
+                        httpMethod: key.httpMethod,
+                      }),
+                    { concurrency: 10 },
+                  );
+
+                  return snaps.filter(
+                    (snap): snap is NonNullable<typeof snap> =>
+                      snap !== undefined,
+                  );
+                }),
+              { concurrency: 5 },
+            );
+
+            return perApi.flat();
+          }),
         reconcile: Effect.fn(function* ({ news: newsIn, output, session }) {
           if (!isResolved(newsIn)) {
             return yield* Effect.die("Method props were not resolved");

package/src/AWS/ApiGateway/RestApi.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
@@ -324,6 +325,23 @@ export const RestApiProvider = () =>
             return { action: "replace" } as const;
           }
         }),
+        // Enumerate every REST API in the account/region. `getRestApis` is a
+        // paginated collection op (items field "items"); collect every page and
+        // map each item through the same snapshot helper `read` uses so each
+        // element is a complete `Attributes` shape.
+        list: () =>
+          ag.getRestApis.pages({}).pipe(
+            Stream.runCollect,
+            Effect.map((chunk) =>
+              Array.from(chunk).flatMap((page) =>
+                (page.items ?? [])
+                  .filter(
+                    (api): api is ag.RestApi & { id: string } => api.id != null,
+                  )
+                  .map((api) => snapshotFromApi(api)),
+              ),
+            ),
+          ),
         read: Effect.fn(function* ({ output }) {
           if (!output?.restApiId) return undefined;
           const api = yield* ag

package/src/AWS/ApiGateway/Stage.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
@@ -554,6 +555,45 @@ export const StageProvider = () =>
           if (!s?.stageName) return undefined;
           return snapshotStage(s, output.restApiId, s.stageName);
         }),
+        // Stage is a sub-resource keyed by (restApiId, stageName). There is
+        // no account-wide stage enumeration API, so enumerate every parent
+        // RestApi first (paginated `getRestApis`) then list the stages per
+        // api (`getStages` needs a restApiId). Map each stage to the full
+        // Attributes shape `read` produces.
+        list: () =>
+          Effect.gen(function* () {
+            const restApiIds = yield* ag.getRestApis.pages({}).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.items ?? [])
+                    .map((api) => api.id)
+                    .filter((id): id is string => id != null),
+                ),
+              ),
+            );
+            const perApi = yield* Effect.forEach(
+              restApiIds,
+              (restApiId) =>
+                ag.getStages({ restApiId }).pipe(
+                  Effect.map((res) =>
+                    (res.item ?? [])
+                      .filter(
+                        (s): s is ag.Stage & { stageName: string } =>
+                          s.stageName != null,
+                      )
+                      .map((s) => snapshotStage(s, restApiId, s.stageName)),
+                  ),
+                  // The parent api may vanish between enumeration and the
+                  // per-api list (race); treat as no stages.
+                  Effect.catchTag("NotFoundException", () =>
+                    Effect.succeed([]),
+                  ),
+                ),
+              { concurrency: 10 },
+            );
+            return perApi.flat();
+          }),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
           const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {

package/src/AWS/ApiGateway/UsagePlan.ts

@@ -1,5 +1,6 @@
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
@@ -263,6 +264,27 @@ export const UsagePlanProvider = () =>
             tags: tagRecord(p.tags),
           };
         }),
+        list: () =>
+          ag.getUsagePlans.pages({}).pipe(
+            Stream.runCollect,
+            Effect.map((chunk) =>
+              Array.from(chunk).flatMap((page) =>
+                (page.items ?? [])
+                  .filter(
+                    (p): p is ag.UsagePlan & { id: string } => p.id != null,
+                  )
+                  .map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    description: p.description,
+                    apiStages: p.apiStages,
+                    throttle: p.throttle,
+                    quota: p.quota,
+                    tags: tagRecord(p.tags),
+                  })),
+              ),
+            ),
+          ),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
           const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {