alchemy 2.0.0-beta.30 → 2.0.0-beta.32

package/src/AWS/ApiGateway/common.ts

@@ -0,0 +1,140 @@
+import * as ag from "@distilled.cloud/aws/api-gateway";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Schedule from "effect/Schedule";
+import { diffTags, normalizeTags } from "../../Tags.ts";
+
+/**
+ * API Gateway serializes mutations to a single RestApi at the control-plane
+ * level: while the API is transitioning between states it responds with a
+ * `BadRequestException` whose message matches one of:
+ *
+ * - `You cannot deploy a RestApi while the apiStatus is UPDATING or FAILED.`
+ * - `There is already an update in progress.`
+ *
+ * These are fundamentally transient — the retry window is short (seconds)
+ * and the only correct response is to wait and try again. Because the
+ * exception is a 4xx, the generic `Retry.transient` policy applied to the
+ * AWS SDK will not retry it, so we apply a targeted retry here for
+ * operations that race with concurrent mutations on the same RestApi
+ * (typically `createDeployment`, `updateStage`, `deleteStage`).
+ */
+const isApiStatusUpdatingError = (error: unknown): boolean => {
+  if (!error || typeof error !== "object") return false;
+  if ((error as { _tag?: string })._tag !== "BadRequestException") return false;
+  const message = (error as { message?: string }).message ?? "";
+  return (
+    message.includes("apiStatus is UPDATING") ||
+    message.includes("already an update in progress")
+  );
+};
+
+/**
+ * `Create/Update/DeleteRestApi` (and a few sibling operations) are governed
+ * by a hard account-wide quota of one request every 30 seconds. The
+ * blanket SDK retry policy caps at 5 attempts with sub-second backoff, so
+ * tests and parallel deploys see `TooManyRequestsException` bubble out as
+ * the SDK gives up well inside the throttle window.
+ */
+const isThrottlingError = (error: unknown): boolean =>
+  typeof error === "object" &&
+  error !== null &&
+  (error as { _tag?: string })._tag === "TooManyRequestsException";
+
+/**
+ * Schedule covering both fast (`apiStatus is UPDATING`) and slow
+ * (throttle) recoverable conditions. Exponential 2s base capped at 35s,
+ * with up to 12 attempts (~5 minutes total). The fast cases settle in the
+ * first few iterations; throttle waits ride the cap until a token is
+ * available.
+ */
+const apiGatewayMutationSchedule = pipe(
+  Schedule.exponential(Duration.seconds(2), 2),
+  Schedule.modifyDelay((d: Duration.Duration) =>
+    Effect.succeed(
+      Duration.isGreaterThan(d, Duration.seconds(35))
+        ? Duration.seconds(35)
+        : d,
+    ),
+  ),
+  Schedule.both(Schedule.recurs(12)),
+  Schedule.addDelay(() =>
+    Effect.succeed(Duration.millis(Math.random() * 1000)),
+  ),
+);
+
+/**
+ * Wraps an API Gateway mutation so that recoverable 4xx responses are
+ * retried with backoff:
+ *
+ * - `BadRequestException` with `apiStatus is UPDATING` or
+ *   `already an update in progress` (transient, clears in seconds)
+ * - `TooManyRequestsException` (account-wide throttle, ~30s window)
+ *
+ * Drop-in usage:
+ *
+ * ```ts
+ * yield* retryOnApiStatusUpdating(
+ *   ag.createDeployment({ ... }),
+ * );
+ * ```
+ */
+export const retryOnApiStatusUpdating = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> =>
+  Effect.retry(effect, {
+    schedule: apiGatewayMutationSchedule,
+    while: (error: unknown) =>
+      isApiStatusUpdatingError(error) || isThrottlingError(error),
+  }) as Effect.Effect<A, E, R>;
+
+export const restApiArn = (region: string, restApiId: string) =>
+  `arn:aws:apigateway:${region}::/restapis/${restApiId}`;
+
+export const stageArn = (
+  region: string,
+  restApiId: string,
+  stageName: string,
+) => `arn:aws:apigateway:${region}::/restapis/${restApiId}/stages/${stageName}`;
+
+export const apiKeyArn = (region: string, apiKeyId: string) =>
+  `arn:aws:apigateway:${region}::/apikeys/${apiKeyId}`;
+
+export const usagePlanArn = (region: string, usagePlanId: string) =>
+  `arn:aws:apigateway:${region}::/usageplans/${usagePlanId}`;
+
+export const domainNameArn = (region: string, domainName: string) =>
+  `arn:aws:apigateway:${region}::/domainnames/${domainName}`;
+
+export const vpcLinkArn = (region: string, vpcLinkId: string) =>
+  `arn:aws:apigateway:${region}::/vpclinks/${vpcLinkId}`;
+
+export const syncTags = Effect.fn(function* ({
+  resourceArn,
+  oldTags,
+  newTags,
+}: {
+  resourceArn: string;
+  oldTags: Record<string, string>;
+  newTags: Record<string, string>;
+}) {
+  const { removed, upsert } = diffTags(oldTags, newTags);
+  if (removed.length > 0) {
+    yield* ag
+      .untagResource({
+        resourceArn,
+        tagKeys: removed,
+      })
+      .pipe(
+        Effect.catchTag("NotFoundException", () => Effect.void),
+        Effect.catchTag("BadRequestException", () => Effect.void),
+      );
+  }
+  if (upsert.length > 0) {
+    yield* ag.tagResource({
+      resourceArn,
+      tags: normalizeTags(upsert),
+    });
+  }
+});

package/src/AWS/ApiGateway/index.ts

@@ -0,0 +1,76 @@
+export { Account, AccountProvider, type AccountProps } from "./Account.ts";
+export { ApiKey, ApiKeyProvider, type ApiKeyProps } from "./ApiKey.ts";
+export {
+  BasePathMapping,
+  BasePathMappingProvider,
+  type BasePathMappingProps,
+} from "./BasePathMapping.ts";
+export {
+  Deployment,
+  DeploymentResource,
+  DeploymentProvider,
+  type DeploymentProps,
+  type DeploymentType,
+} from "./Deployment.ts";
+export {
+  DomainName,
+  DomainNameProvider,
+  type DomainNameProps,
+} from "./DomainName.ts";
+export {
+  GatewayResponse,
+  GatewayResponseProvider,
+  type GatewayResponseProps,
+} from "./GatewayResponse.ts";
+export {
+  Resource,
+  GatewayResource,
+  ResourceProvider,
+  type ApiGatewayResource,
+  type ApiGatewayResourceProps,
+} from "./GatewayResource.ts";
+export {
+  Method,
+  MethodResource,
+  MethodProvider,
+  type MethodIntegrationProps,
+  type MethodProps,
+  type MethodType,
+} from "./Method.ts";
+export {
+  RestApi,
+  RestApiProvider,
+  type RestApiProps,
+  type RestApiBinding,
+} from "./RestApi.ts";
+export {
+  Stage,
+  StageResource,
+  StageProvider,
+  type StageProps,
+} from "./Stage.ts";
+export {
+  UsagePlan,
+  UsagePlanProvider,
+  type UsagePlanProps,
+} from "./UsagePlan.ts";
+export {
+  UsagePlanKey,
+  UsagePlanKeyProvider,
+  type UsagePlanKeyProps,
+} from "./UsagePlanKey.ts";
+export {
+  Authorizer,
+  AuthorizerProvider,
+  type AuthorizerProps,
+} from "./Authorizer.ts";
+export {
+  restApiArn,
+  stageArn,
+  apiKeyArn,
+  usagePlanArn,
+  domainNameArn,
+  vpcLinkArn,
+  syncTags,
+} from "./common.ts";
+export { VpcLink, VpcLinkProvider, type VpcLinkProps } from "./VpcLink.ts";

package/src/AWS/AutoScaling/AutoScalingGroup.ts

@@ -283,9 +283,10 @@ export const AutoScalingGroupProvider = () =>
           const group = yield* describeGroup(name);
           return group ? toAttributes(group) : undefined;
         }),
-        create: Effect.fn(function* ({ id, news, output, session }) {
-          const autoScalingGroupName = yield* toName(id, news);
-          const tags = {
+        reconcile: Effect.fn(function* ({ id, news, output, session }) {
+          const autoScalingGroupName =
+            output?.autoScalingGroupName ?? (yield* toName(id, news));
+          const desiredTags = {
             ...(yield* createInternalTags(id)),
             ...news.tags,
           };
@@ -293,125 +294,105 @@ export const AutoScalingGroupProvider = () =>
             (news.targetGroupArns ?? []) as string[],
           );
           const launchTemplate = toLaunchTemplateSpec(news.launchTemplate);
-          const existing =
-            output?.autoScalingGroupName === autoScalingGroupName
-              ? yield* describeGroup(autoScalingGroupName)
-              : yield* describeGroup(autoScalingGroupName);
+          const healthCheckType =
+            news.healthCheckType ??
+            (targetGroupArns.length > 0 ? "ELB" : "EC2");
 
-          if (!existing) {
-            yield* autoscaling.createAutoScalingGroup({
-              AutoScalingGroupName: autoScalingGroupName,
-              MinSize: news.minSize,
-              MaxSize: news.maxSize,
-              DesiredCapacity: news.desiredCapacity ?? news.minSize,
-              LaunchTemplate: launchTemplate,
-              VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
-              TargetGroupARNs: targetGroupArns,
-              HealthCheckType:
-                news.healthCheckType ??
-                (targetGroupArns.length > 0 ? "ELB" : "EC2"),
-              HealthCheckGracePeriod: news.healthCheckGracePeriod,
-              DefaultCooldown: news.defaultCooldown,
-              TerminationPolicies: news.terminationPolicies,
-              Tags: toTags(autoScalingGroupName, tags),
-            } as any);
-          } else {
-            yield* autoscaling.updateAutoScalingGroup({
-              AutoScalingGroupName: autoScalingGroupName,
-              MinSize: news.minSize,
-              MaxSize: news.maxSize,
-              DesiredCapacity: news.desiredCapacity ?? news.minSize,
-              LaunchTemplate: launchTemplate,
-              VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
-              HealthCheckType:
-                news.healthCheckType ??
-                (targetGroupArns.length > 0 ? "ELB" : "EC2"),
-              HealthCheckGracePeriod: news.healthCheckGracePeriod,
-              DefaultCooldown: news.defaultCooldown,
-              TerminationPolicies: news.terminationPolicies,
-            } as any);
-            yield* syncTargetGroups({
-              autoScalingGroupName,
-              oldTargetGroupArns: sortStrings(existing.TargetGroupARNs ?? []),
-              newTargetGroupArns: targetGroupArns,
-            });
-            yield* syncTags({
-              autoScalingGroupName,
-              oldTags: toAttributes(existing).tags,
-              newTags: tags,
-            });
-          }
+          // Observe — fetch live state. `describeAutoScalingGroups` returns
+          // an empty list when the ASG is missing; we never trust `output`
+          // alone since the ASG may have been deleted out of band.
+          let existing = yield* describeGroup(autoScalingGroupName);
 
-          const group = yield* describeGroup(autoScalingGroupName).pipe(
-            Effect.filterOrFail(
-              Boolean,
-              () =>
-                new Error(
-                  `Auto Scaling Group '${autoScalingGroupName}' was not readable after create`,
+          // Ensure — create the ASG if missing. `createAutoScalingGroup`
+          // raises `AlreadyExistsFault` on a race; we fall through to the
+          // sync path on that case.
+          if (!existing) {
+            yield* autoscaling
+              .createAutoScalingGroup({
+                AutoScalingGroupName: autoScalingGroupName,
+                MinSize: news.minSize,
+                MaxSize: news.maxSize,
+                DesiredCapacity: news.desiredCapacity ?? news.minSize,
+                LaunchTemplate: launchTemplate,
+                VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
+                TargetGroupARNs: targetGroupArns,
+                HealthCheckType: healthCheckType,
+                HealthCheckGracePeriod: news.healthCheckGracePeriod,
+                DefaultCooldown: news.defaultCooldown,
+                TerminationPolicies: news.terminationPolicies,
+                Tags: toTags(autoScalingGroupName, desiredTags),
+              } as any)
+              .pipe(
+                Effect.catch((error: any) =>
+                  error?._tag === "AlreadyExistsFault"
+                    ? Effect.void
+                    : Effect.fail(error),
                 ),
-            ),
-            Effect.retry({
-              while: () => true,
-              schedule: Schedule.recurs(8).pipe(
-                Schedule.both(Schedule.exponential("250 millis")),
-              ),
-            }),
-          );
+              );
 
-          yield* session.note(autoScalingGroupName);
-          return toAttributes(group);
-        }),
-        update: Effect.fn(function* ({ id, news, olds, output, session }) {
-          const tags = {
-            ...(yield* createInternalTags(id)),
-            ...news.tags,
-          };
-          const oldTags = {
-            ...(yield* createInternalTags(id)),
-            ...olds.tags,
-          };
-          const targetGroupArns = sortStrings(
-            (news.targetGroupArns ?? []) as string[],
-          );
+            existing = yield* describeGroup(autoScalingGroupName).pipe(
+              Effect.filterOrFail(
+                Boolean,
+                () =>
+                  new Error(
+                    `Auto Scaling Group '${autoScalingGroupName}' was not readable after create`,
+                  ),
+              ),
+              Effect.retry({
+                while: () => true,
+                schedule: Schedule.recurs(8).pipe(
+                  Schedule.both(Schedule.exponential("250 millis")),
+                ),
+              }),
+            );
+          }
 
+          // Sync core ASG configuration — `updateAutoScalingGroup`
+          // overwrites min/max/desired/template/subnets/health-check
+          // settings in one call, so we issue it unconditionally
+          // (idempotent for matching values).
           yield* autoscaling.updateAutoScalingGroup({
-            AutoScalingGroupName: output.autoScalingGroupName,
+            AutoScalingGroupName: autoScalingGroupName,
             MinSize: news.minSize,
             MaxSize: news.maxSize,
             DesiredCapacity: news.desiredCapacity ?? news.minSize,
-            LaunchTemplate: toLaunchTemplateSpec(news.launchTemplate),
+            LaunchTemplate: launchTemplate,
             VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
-            HealthCheckType:
-              news.healthCheckType ??
-              (targetGroupArns.length > 0 ? "ELB" : "EC2"),
+            HealthCheckType: healthCheckType,
             HealthCheckGracePeriod: news.healthCheckGracePeriod,
             DefaultCooldown: news.defaultCooldown,
             TerminationPolicies: news.terminationPolicies,
           } as any);
 
+          // Sync target groups — observed cloud attachments vs desired.
+          const observedAttrs = toAttributes(existing);
           yield* syncTargetGroups({
-            autoScalingGroupName: output.autoScalingGroupName,
-            oldTargetGroupArns: sortStrings(
-              (olds.targetGroupArns ?? []) as string[],
-            ),
+            autoScalingGroupName,
+            oldTargetGroupArns: sortStrings(existing.TargetGroupARNs ?? []),
             newTargetGroupArns: targetGroupArns,
           });
+
+          // Sync tags — observed cloud tags vs desired. Adoption brings
+          // tags through `existing.Tags`; we converge regardless of what
+          // was there before.
           yield* syncTags({
-            autoScalingGroupName: output.autoScalingGroupName,
-            oldTags,
-            newTags: tags,
+            autoScalingGroupName,
+            oldTags: observedAttrs.tags,
+            newTags: desiredTags,
           });
 
-          const group = yield* describeGroup(output.autoScalingGroupName).pipe(
+          // Re-read final state so attributes reflect post-sync cloud
+          // state.
+          const group = yield* describeGroup(autoScalingGroupName).pipe(
             Effect.filterOrFail(
               Boolean,
               () =>
                 new Error(
-                  `Auto Scaling Group '${output.autoScalingGroupName}' was not readable after update`,
+                  `Auto Scaling Group '${autoScalingGroupName}' was not readable after reconcile`,
                 ),
             ),
           );
-          yield* session.note(output.autoScalingGroupName);
+          yield* session.note(autoScalingGroupName);
           return toAttributes(group);
         }),
         delete: Effect.fn(function* ({ output }) {

package/src/AWS/AutoScaling/LaunchTemplate.ts

@@ -12,20 +12,20 @@ import { createPhysicalName } from "../../PhysicalName.ts";
 import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { Stack } from "../../Stack.ts";
 import { Stage } from "../../Stage.ts";
 import { createInternalTags, diffTags, hasTags } from "../../Tags.ts";
-import type { AccountID } from "../Environment.ts";
-import { AWSEnvironment } from "../Environment.ts";
 import { Assets } from "../Assets.ts";
 import type { SecurityGroupId } from "../EC2/SecurityGroup.ts";
 import {
-  createEc2HostExecutionContext,
+  createEc2HostRuntimeContext,
   createEc2HostedSupport,
-  type Ec2HostExecutionContext,
+  type Ec2HostRuntimeContext,
 } from "../EC2/hosted.ts";
+import type { AccountID } from "../Environment.ts";
+import { AWSEnvironment } from "../Environment.ts";
 import type { PolicyStatement } from "../IAM/Policy.ts";
+import type { Providers } from "../Providers.ts";
 import type { RegionID } from "../Region.ts";
 
 export type LaunchTemplateId = `lt-${string}`;
@@ -134,7 +134,7 @@ export type LaunchTemplateServices = Credentials | Region;
 
 export type LaunchTemplateShape = Main<LaunchTemplateServices>;
 
-export type LaunchTemplateExecutionContext = Ec2HostExecutionContext;
+export type LaunchTemplateRuntimeContext = Ec2HostRuntimeContext;
 
 /**
  * A launch template that preserves the `Host` authoring model used by
@@ -164,9 +164,9 @@ export const LaunchTemplate: Platform<
   LaunchTemplate,
   LaunchTemplateServices,
   LaunchTemplateShape,
-  LaunchTemplateExecutionContext
+  LaunchTemplateRuntimeContext
 > = Platform("AWS.AutoScaling.LaunchTemplate", {
-  createExecutionContext: createEc2HostExecutionContext(
+  createRuntimeContext: createEc2HostRuntimeContext(
     "AWS.AutoScaling.LaunchTemplate",
   ),
 });
@@ -372,9 +372,16 @@ export const LaunchTemplateProvider = () =>
               })
             : undefined;
         }),
-        create: Effect.fn(function* ({ id, news, output, bindings, session }) {
-          const launchTemplateName = yield* toName(id, news);
-          const tags = {
+        reconcile: Effect.fn(function* ({
+          id,
+          news,
+          output,
+          bindings,
+          session,
+        }) {
+          const launchTemplateName =
+            output?.launchTemplateName ?? (yield* toName(id, news));
+          const desiredTags = {
             ...(yield* createInternalTags(id)),
             ...news.tags,
           };
@@ -384,121 +391,90 @@ export const LaunchTemplateProvider = () =>
             bindings,
             output,
           });
-          const existing =
+
+          // Observe — fetch live cloud state. We try both lookup paths
+          // (id from output, name from desired) so the reconciler
+          // converges whether `output` is fresh, stale, or missing.
+          let existing =
             (output?.launchTemplateId &&
-              (yield* describeById(output.launchTemplateId))) ??
+              (yield* describeById(output.launchTemplateId))) ||
             (yield* describeByName(launchTemplateName));
 
-          if (existing) {
-            if (!hasTags(tags, toTagRecord(existing.Tags))) {
-              return yield* Effect.fail(
-                new Error(
-                  `Launch template '${launchTemplateName}' already exists and is not managed by alchemy`,
-                ),
-              );
-            }
-            yield* createVersion({
-              launchTemplateId: existing.LaunchTemplateId as LaunchTemplateId,
-              news,
-              runtime,
-            });
-            yield* syncTemplateTags({
-              launchTemplateId: existing.LaunchTemplateId as LaunchTemplateId,
-              oldTags: toTagRecord(existing.Tags),
-              newTags: tags,
-            });
-            const refreshed = yield* describeById(existing.LaunchTemplateId!);
-            if (!refreshed) {
+          // Ensure — create the launch template if missing. We must
+          // verify alchemy ownership via tags here (since this resource
+          // does not implement `read` adoption gating).
+          if (!existing) {
+            const created = yield* ec2.createLaunchTemplate({
+              LaunchTemplateName: launchTemplateName,
+              VersionDescription: runtime.code?.hash ?? "alchemy-create",
+              TagSpecifications: [
+                {
+                  ResourceType: "launch-template",
+                  Tags: Object.entries(desiredTags).map(([Key, Value]) => ({
+                    Key,
+                    Value,
+                  })),
+                },
+              ],
+              LaunchTemplateData: hosted.buildLaunchTemplateData(
+                {
+                  imageId: news.imageId,
+                  instanceType: news.instanceType,
+                  keyName: news.keyName,
+                  securityGroupIds: news.securityGroupIds as
+                    | string[]
+                    | undefined,
+                  associatePublicIpAddress: news.associatePublicIpAddress,
+                  tags: desiredTags,
+                },
+                runtime,
+              ),
+            } as any);
+            const template = created.LaunchTemplate;
+            if (!template?.LaunchTemplateId || !template.LaunchTemplateName) {
               return yield* Effect.fail(
                 new Error(
-                  `Launch template '${launchTemplateName}' was not readable after update`,
+                  `createLaunchTemplate returned no launch template for '${id}'`,
                 ),
               );
             }
-            yield* session.note(refreshed.LaunchTemplateId!);
-            return toAttributes(refreshed, runtime);
+            yield* session.note(template.LaunchTemplateId);
+            return toAttributes(template as ec2.LaunchTemplate, runtime);
           }
 
-          const created = yield* ec2.createLaunchTemplate({
-            LaunchTemplateName: launchTemplateName,
-            VersionDescription: runtime.code?.hash ?? "alchemy-create",
-            TagSpecifications: [
-              {
-                ResourceType: "launch-template",
-                Tags: Object.entries(tags).map(([Key, Value]) => ({
-                  Key,
-                  Value,
-                })),
-              },
-            ],
-            LaunchTemplateData: hosted.buildLaunchTemplateData(
-              {
-                imageId: news.imageId,
-                instanceType: news.instanceType,
-                keyName: news.keyName,
-                securityGroupIds: news.securityGroupIds as string[] | undefined,
-                associatePublicIpAddress: news.associatePublicIpAddress,
-                tags,
-              },
-              runtime,
-            ),
-          } as any);
-          const template = created.LaunchTemplate;
-          if (!template?.LaunchTemplateId || !template.LaunchTemplateName) {
+          if (!hasTags(desiredTags, toTagRecord(existing.Tags))) {
             return yield* Effect.fail(
               new Error(
-                `createLaunchTemplate returned no launch template for '${id}'`,
+                `Launch template '${launchTemplateName}' already exists and is not managed by alchemy`,
               ),
             );
           }
 
-          yield* session.note(template.LaunchTemplateId);
-          return toAttributes(template as ec2.LaunchTemplate, runtime);
-        }),
-        update: Effect.fn(function* ({
-          id,
-          news,
-          olds,
-          output,
-          bindings,
-          session,
-        }) {
-          const tags = {
-            ...(yield* createInternalTags(id)),
-            ...news.tags,
-          };
-          const oldTags = {
-            ...(yield* createInternalTags(id)),
-            ...olds.tags,
-          };
-          const runtime = yield* hosted.resolveHostedRuntime({
-            id,
-            news,
-            bindings,
-            output,
-          });
-
+          // Sync version — each reconcile creates a new version pinned as
+          // the default. ASGs that reference `$Default` automatically
+          // pick up the new version.
           yield* createVersion({
-            launchTemplateId: output.launchTemplateId,
+            launchTemplateId: existing.LaunchTemplateId as LaunchTemplateId,
             news,
             runtime,
           });
+
+          // Sync tags — diff observed cloud tags against desired.
           yield* syncTemplateTags({
-            launchTemplateId: output.launchTemplateId,
-            oldTags,
-            newTags: tags,
+            launchTemplateId: existing.LaunchTemplateId as LaunchTemplateId,
+            oldTags: toTagRecord(existing.Tags),
+            newTags: desiredTags,
           });
 
-          const refreshed = yield* describeById(output.launchTemplateId);
+          const refreshed = yield* describeById(existing.LaunchTemplateId!);
           if (!refreshed) {
             return yield* Effect.fail(
               new Error(
-                `Launch template '${output.launchTemplateName}' was not readable after update`,
+                `Launch template '${launchTemplateName}' was not readable after reconcile`,
               ),
             );
           }
-
-          yield* session.note(output.launchTemplateId);
+          yield* session.note(refreshed.LaunchTemplateId!);
           return toAttributes(refreshed, runtime);
         }),
         delete: Effect.fn(function* ({ output, session }) {