@aws-cdk/integ-runner 2.197.14 → 2.197.15

package/lib/workers/extract/index.js

@@ -4670,7 +4670,7 @@ var require_semver2 = __commonJS({
 // ../cloud-assembly-schema/cli-version.json
 var require_cli_version = __commonJS({
   "../cloud-assembly-schema/cli-version.json"(exports2, module2) {
-    module2.exports = { version: "2.1118.1" };
+    module2.exports = { version: "2.1118.2" };
   }
 });
 
@@ -112855,7 +112855,7 @@ var require_dist_cjs56 = __commonJS({
         __name(this, "ListResourcesCommand");
       }
     };
-    var UpdateResourceCommand = class extends smithyClient.Command.classBuilder().ep(commonParams6).m(function(Command, cs, config, o6) {
+    var UpdateResourceCommand2 = class extends smithyClient.Command.classBuilder().ep(commonParams6).m(function(Command, cs, config, o6) {
       return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
     }).s("CloudApiService", "UpdateResource", {}).n("CloudControlClient", "UpdateResourceCommand").sc(schemas_0.UpdateResource$).build() {
       static {
@@ -112918,7 +112918,7 @@ var require_dist_cjs56 = __commonJS({
       GetResourceRequestStatusCommand,
       ListResourceRequestsCommand,
       ListResourcesCommand: ListResourcesCommand2,
-      UpdateResourceCommand
+      UpdateResourceCommand: UpdateResourceCommand2
     };
     var paginators = {
       paginateListResourceRequests,
@@ -112979,7 +112979,7 @@ var require_dist_cjs56 = __commonJS({
     exports2.ListResourcesCommand = ListResourcesCommand2;
     exports2.Operation = Operation;
     exports2.OperationStatus = OperationStatus;
-    exports2.UpdateResourceCommand = UpdateResourceCommand;
+    exports2.UpdateResourceCommand = UpdateResourceCommand2;
     exports2.paginateListResourceRequests = paginateListResourceRequests;
     exports2.paginateListResources = paginateListResources;
     exports2.waitForResourceRequestSuccess = waitForResourceRequestSuccess;
@@ -118643,7 +118643,7 @@ var require_dist_cjs57 = __commonJS({
         __name(this, "DescribeStackSetOperationCommand");
       }
     };
-    var DescribeTypeCommand = class extends smithyClient.Command.classBuilder().ep(commonParams6).m(function(Command, cs, config, o6) {
+    var DescribeTypeCommand2 = class extends smithyClient.Command.classBuilder().ep(commonParams6).m(function(Command, cs, config, o6) {
       return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
     }).s("CloudFormation", "DescribeType", {}).n("CloudFormationClient", "DescribeTypeCommand").sc(schemas_0.DescribeType$).build() {
       static {
@@ -119941,7 +119941,7 @@ var require_dist_cjs57 = __commonJS({
       DescribeStacksCommand: DescribeStacksCommand2,
       DescribeStackSetCommand,
       DescribeStackSetOperationCommand,
-      DescribeTypeCommand,
+      DescribeTypeCommand: DescribeTypeCommand2,
       DescribeTypeRegistrationCommand,
       DetectStackDriftCommand: DetectStackDriftCommand2,
       DetectStackResourceDriftCommand: DetectStackResourceDriftCommand2,
@@ -120622,7 +120622,7 @@ var require_dist_cjs57 = __commonJS({
     exports2.DescribeStackSetCommand = DescribeStackSetCommand;
     exports2.DescribeStackSetOperationCommand = DescribeStackSetOperationCommand;
     exports2.DescribeStacksCommand = DescribeStacksCommand2;
-    exports2.DescribeTypeCommand = DescribeTypeCommand;
+    exports2.DescribeTypeCommand = DescribeTypeCommand2;
     exports2.DescribeTypeRegistrationCommand = DescribeTypeRegistrationCommand;
     exports2.DetailedStatus = DetailedStatus;
     exports2.DetectStackDriftCommand = DetectStackDriftCommand2;
@@ -285216,7 +285216,8 @@ var init_sdk = __esm({
         const client = new import_client_cloudcontrol.CloudControlClient(this.config);
         return {
           listResources: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudcontrol.ListResourcesCommand(input)), "listResources"),
-          getResource: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudcontrol.GetResourceCommand(input)), "getResource")
+          getResource: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudcontrol.GetResourceCommand(input)), "getResource"),
+          updateResource: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudcontrol.UpdateResourceCommand(input)), "updateResource")
         };
       }
       cloudFormation() {
@@ -285242,6 +285243,7 @@ var init_sdk = __esm({
           describeStackResourceDrifts: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.DescribeStackResourceDriftsCommand(input)), "describeStackResourceDrifts"),
           describeStacks: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.DescribeStacksCommand(input)), "describeStacks"),
           describeStackResources: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.DescribeStackResourcesCommand(input)), "describeStackResources"),
+          describeType: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.DescribeTypeCommand(input)), "describeType"),
           executeChangeSet: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.ExecuteChangeSetCommand(input)), "executeChangeSet"),
           getGeneratedTemplate: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.GetGeneratedTemplateCommand(input)), "getGeneratedTemplate"),
           getTemplate: /* @__PURE__ */ __name((input) => client.send(new import_client_cloudformation.GetTemplateCommand(input)), "getTemplate"),
@@ -285423,13 +285425,13 @@ var init_sdk = __esm({
           updateFunctionCode: /* @__PURE__ */ __name((input) => client.send(new import_client_lambda.UpdateFunctionCodeCommand(input)), "updateFunctionCode"),
           updateFunctionConfiguration: /* @__PURE__ */ __name((input) => client.send(new import_client_lambda.UpdateFunctionConfigurationCommand(input)), "updateFunctionConfiguration"),
           // Waiters
-          waitUntilFunctionUpdated: /* @__PURE__ */ __name((delaySeconds, input) => {
+          waitUntilFunctionUpdated: /* @__PURE__ */ __name((minDelaySeconds, maxDelaySeconds, input) => {
             return (0, import_client_lambda.waitUntilFunctionUpdatedV2)(
               {
                 client,
-                maxDelay: delaySeconds,
-                minDelay: delaySeconds,
-                maxWaitTime: delaySeconds * 60
+                maxDelay: maxDelaySeconds,
+                minDelay: minDelaySeconds,
+                maxWaitTime: maxDelaySeconds * 60
               },
               input
             );
@@ -292013,7 +292015,7 @@ async function asyncGlobalReplace(str, regex, cb) {
   ret.push(str.slice(start));
   return ret.join("");
 }
-var LazyListStackResources, LazyLookupExport, CfnEvaluationException, EvaluateCloudFormationTemplate, RESOURCE_TYPE_SPECIAL_NAMES, RESOURCE_TYPE_ATTRIBUTES_FORMATS;
+var LazyListStackResources, LazyLookupExport, CfnEvaluationException, EvaluateCloudFormationTemplate, RESOURCE_TYPE_PRIMARY_IDENTIFIERS, RESOURCE_TYPE_SPECIAL_NAMES, RESOURCE_TYPE_ATTRIBUTES_FORMATS;
 var init_evaluate_cloudformation_template = __esm({
   "../toolkit-lib/lib/api/cloudformation/evaluate-cloudformation-template.ts"() {
     "use strict";
@@ -292099,6 +292101,7 @@ var init_evaluate_cloudformation_template = __esm({
       stackResources;
       lookupExport;
       cachedUrlSuffix;
+      _cloudControl;
       constructor(props) {
         this.stackArtifact = props.stackArtifact;
         this.stackName = props.stackName ?? props.stackArtifact.stackName;
@@ -292117,6 +292120,12 @@ var init_evaluate_cloudformation_template = __esm({
         this.stackResources = new LazyListStackResources(this.sdk, this.stackName);
         this.lookupExport = new LazyLookupExport(this.sdk);
       }
+      get cloudControl() {
+        if (!this._cloudControl) {
+          this._cloudControl = this.sdk.cloudControl();
+        }
+        return this._cloudControl;
+      }
       // clones current EvaluateCloudFormationTemplate object, but updates the stack name
       async createNestedEvaluateCloudFormationTemplate(stackName, nestedTemplate, nestedStackParameters) {
         const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters);
@@ -292250,6 +292259,41 @@ var init_evaluate_cloudformation_template = __esm({
         }
         return cfnExpression;
       }
+      /**
+       * Best-effort attempt to construct the Cloud Control API primary identifier for a resource.
+       *
+       * Cloud Control compound identifiers are pipe-delimited, ordered by the `primaryIdentifier`
+       * array in the resource type schema (e.g. `DatabaseName|TableName` for `AWS::Glue::Table`).
+       *
+       * CloudFormation's `PhysicalResourceId` (the `physicalId` parameter here) is the `Ref` return
+       * value for the resource, which is resource-type-specific and may not correspond to the Cloud
+       * Control Primary Identifier.
+       *
+       * For properties present in the template, we resolve them directly. For properties NOT in the
+       * template (e.g. service-generated read-only values), we fall back to `physicalId`. This is
+       * only correct when:
+       *
+       * - Exactly one property in the identifier is missing from the template, AND
+       * - That property happens to be the one that `Ref` returns for this resource type.
+       *
+       * If multiple properties are missing, `physicalId` is reused for all of them.
+       */
+      async evaluateCloudControlIdentifier(logicalId, resourceType, physicalId) {
+        if (resourceType in RESOURCE_TYPE_PRIMARY_IDENTIFIERS) {
+          const primaryProps = RESOURCE_TYPE_PRIMARY_IDENTIFIERS[resourceType];
+          const parts = [];
+          for (const propName of primaryProps) {
+            const templateVal = this.getResourceProperty(logicalId, propName);
+            if (templateVal) {
+              parts.push(await this.evaluateCfnExpression(templateVal));
+            } else {
+              parts.push(physicalId);
+            }
+          }
+          return parts.join("|");
+        }
+        return physicalId;
+      }
       getResourceProperty(logicalId, propertyName) {
         return this.template.Resources?.[logicalId]?.Properties?.[propertyName];
       }
@@ -292336,33 +292380,43 @@ var init_evaluate_cloudformation_template = __esm({
         }
         return void 0;
       }
-      formatResourceAttribute(resource, attribute) {
+      async formatResourceAttribute(resource, attribute) {
         const physicalId = resource.PhysicalResourceId;
         if (!attribute) {
           return physicalId;
         }
         const resourceTypeFormats = RESOURCE_TYPE_ATTRIBUTES_FORMATS[resource.ResourceType];
-        if (!resourceTypeFormats) {
-          throw new CfnEvaluationException(
-            `We don't support attributes of the '${resource.ResourceType}' resource. This is a CDK limitation. Please report it at https://github.com/aws/aws-cdk/issues/new/choose`
-          );
+        if (resourceTypeFormats) {
+          const attributeFormatFunc = resourceTypeFormats[attribute];
+          if (attributeFormatFunc) {
+            const service = this.getServiceOfResource(resource);
+            const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource);
+            return attributeFormatFunc({
+              partition: this.partition,
+              service,
+              region: this.region,
+              account: this.account,
+              resourceType: resourceTypeArnPart,
+              resourceName: physicalId
+            });
+          }
         }
-        const attributeFmtFunc = resourceTypeFormats[attribute];
-        if (!attributeFmtFunc) {
-          throw new CfnEvaluationException(
-            `We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. Please report it at https://github.com/aws/aws-cdk/issues/new/choose`
-          );
+        try {
+          const identifier = await this.evaluateCloudControlIdentifier(resource.LogicalResourceId, resource.ResourceType, physicalId);
+          const response = await this.cloudControl.getResource({
+            TypeName: resource.ResourceType,
+            Identifier: identifier
+          });
+          const props = JSON.parse(response.ResourceDescription?.Properties ?? "{}");
+          if (attribute in props) {
+            return props[attribute];
+          }
+        } catch (error4) {
+          throw new CfnEvaluationException(`Could not find '${attribute}' attribute of the '${resource.ResourceType}' resource becausean error occured while attempting to retrieve the information: '${error4.name}:${error4.message}'`);
         }
-        const service = this.getServiceOfResource(resource);
-        const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource);
-        return attributeFmtFunc({
-          partition: this.partition,
-          service,
-          region: this.region,
-          account: this.account,
-          resourceType: resourceTypeArnPart,
-          resourceName: physicalId
-        });
+        throw new CfnEvaluationException(
+          `We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. Please report it at https://github.com/aws/aws-cdk/issues/new/choose`
+        );
       }
       getServiceOfResource(resource) {
         return resource.ResourceType.split("::")[1].toLowerCase();
@@ -292376,6 +292430,75 @@ var init_evaluate_cloudformation_template = __esm({
         );
       }
     };
+    RESOURCE_TYPE_PRIMARY_IDENTIFIERS = {
+      "AWS::ApiGateway::Authorizer": ["RestApiId", "AuthorizerId"],
+      "AWS::ApiGateway::Deployment": ["DeploymentId", "RestApiId"],
+      "AWS::ApiGateway::Model": ["RestApiId", "Name"],
+      "AWS::ApiGateway::RequestValidator": ["RestApiId", "RequestValidatorId"],
+      "AWS::ApiGateway::DocumentationPart": ["DocumentationPartId", "RestApiId"],
+      "AWS::ApiGateway::Resource": ["RestApiId", "ResourceId"],
+      "AWS::ApiGateway::Stage": ["RestApiId", "StageName"],
+      "AWS::ApiGatewayV2::ApiMapping": ["ApiMappingId", "DomainName"],
+      "AWS::ApiGatewayV2::Authorizer": ["AuthorizerId", "ApiId"],
+      "AWS::ApiGatewayV2::Deployment": ["ApiId", "DeploymentId"],
+      "AWS::ApiGatewayV2::Integration": ["ApiId", "IntegrationId"],
+      "AWS::ApiGatewayV2::IntegrationResponse": ["ApiId", "IntegrationId", "IntegrationResponseId"],
+      "AWS::ApiGatewayV2::Model": ["ApiId", "ModelId"],
+      "AWS::ApiGatewayV2::Route": ["ApiId", "RouteId"],
+      "AWS::ApiGatewayV2::RouteResponse": ["ApiId", "RouteId", "RouteResponseId"],
+      "AWS::ApiGatewayV2::Stage": ["Id"],
+      "AWS::AppConfig::ConfigurationProfile": ["ApplicationId", "ConfigurationProfileId"],
+      "AWS::AppConfig::Environment": ["ApplicationId", "EnvironmentId"],
+      "AWS::AppConfig::HostedConfigurationVersion": ["ApplicationId", "ConfigurationProfileId", "VersionNumber"],
+      "AWS::AppMesh::GatewayRoute": ["Id"],
+      "AWS::AppMesh::Mesh": ["Id"],
+      "AWS::AppMesh::Route": ["Id"],
+      "AWS::AppMesh::VirtualGateway": ["Id"],
+      "AWS::AppMesh::VirtualNode": ["Id"],
+      "AWS::AppMesh::VirtualRouter": ["Id"],
+      "AWS::AppMesh::VirtualService": ["Id"],
+      "AWS::AppSync::ApiKey": ["ApiKeyId"],
+      "AWS::AppSync::GraphQLApi": ["ApiId"],
+      "AWS::Batch::JobDefinition": ["JobDefinitionName"],
+      "AWS::CloudWatch::InsightRule": ["Id"],
+      "AWS::CodeBuild::Project": ["Id"],
+      "AWS::CodeBuild::ReportGroup": ["Id"],
+      "AWS::CodeDeploy::DeploymentGroup": ["ApplicationName", "DeploymentGroupName"],
+      "AWS::CodePipeline::Webhook": ["Id"],
+      "AWS::Cognito::UserPoolClient": ["UserPoolId", "ClientId"],
+      "AWS::Cognito::UserPoolDomain": ["UserPoolId", "Domain"],
+      "AWS::Cognito::UserPoolGroup": ["UserPoolId", "GroupName"],
+      "AWS::Cognito::UserPoolIdentityProvider": ["UserPoolId", "ProviderName"],
+      "AWS::Cognito::UserPoolResourceServer": ["UserPoolId", "Identifier"],
+      "AWS::Cognito::UserPoolUser": ["UserPoolId", "Username"],
+      "AWS::DAX::Cluster": ["Id"],
+      "AWS::DAX::ParameterGroup": ["Id"],
+      "AWS::DAX::SubnetGroup": ["Id"],
+      "AWS::DMS::EventSubscription": ["Id"],
+      "AWS::EC2::EIP": ["PublicIp", "AllocationId"],
+      "AWS::ECS::Service": ["ServiceArn", "Cluster"],
+      "AWS::ElastiCache::CacheCluster": ["Id"],
+      "AWS::ElasticLoadBalancing::LoadBalancer": ["Id"],
+      "AWS::ElastiCache::User": ["UserId"],
+      "AWS::Elasticsearch::Domain": ["Id"],
+      "AWS::Events::Rule": ["Arn"],
+      "AWS::EventSchemas::RegistryPolicy": ["Id"],
+      "AWS::Glue::DevEndpoint": ["Id"],
+      "AWS::Glue::Workflow": ["Id"],
+      "AWS::IoT::Policy": ["Id"],
+      "AWS::Logs::LogStream": ["LogGroupName", "LogStreamName"],
+      "AWS::Logs::SubscriptionFilter": ["FilterName", "LogGroupName"],
+      "AWS::MediaConvert::JobTemplate": ["Id"],
+      "AWS::MediaConvert::Preset": ["Id"],
+      "AWS::MediaConvert::Queue": ["Id"],
+      "AWS::Route53::RecordSet": ["Id"],
+      "AWS::SageMaker::Device": ["Device/DeviceName"],
+      "AWS::SecretsManager::ResourcePolicy": ["Id"],
+      "AWS::SecretsManager::SecretTargetAttachment": ["Id"],
+      "AWS::SES::ReceiptRuleSet": ["Id"],
+      "AWS::SSM::MaintenanceWindowTarget": ["WindowId", "WindowTargetId"],
+      "AWS::SSM::MaintenanceWindowTask": ["WindowId", "WindowTaskId"]
+    };
     RESOURCE_TYPE_SPECIAL_NAMES = {
       "AWS::Events::EventBus": {
         resourceType: "event-bus"
@@ -310555,156 +310678,6 @@ var init_appsync_mapping_templates = __esm({
   }
 });
 
-// ../toolkit-lib/lib/api/hotswap/bedrock-agentcore-runtimes.ts
-async function isHotswappableBedrockAgentCoreRuntimeChange(logicalId, change, evaluateCfnTemplate) {
-  if (change.newValue.Type !== "AWS::BedrockAgentCore::Runtime") {
-    return [];
-  }
-  const ret = [];
-  const classifiedChanges = classifyChanges(change, [
-    "AgentRuntimeArtifact",
-    "EnvironmentVariables",
-    "Description"
-  ]);
-  classifiedChanges.reportNonHotswappablePropertyChanges(ret);
-  const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
-  if (namesOfHotswappableChanges.length === 0) {
-    return ret;
-  }
-  const agentRuntimeId = await evaluateCfnTemplate.findPhysicalNameFor(logicalId);
-  if (!agentRuntimeId) {
-    return ret;
-  }
-  const runtimeChange = await evaluateBedrockAgentCoreRuntimeProps(
-    classifiedChanges.hotswappableProps,
-    evaluateCfnTemplate
-  );
-  ret.push({
-    change: {
-      cause: change,
-      resources: [{
-        logicalId,
-        resourceType: change.newValue.Type,
-        physicalName: agentRuntimeId,
-        metadata: evaluateCfnTemplate.metadataFor(logicalId)
-      }]
-    },
-    hotswappable: true,
-    service: "bedrock-agentcore",
-    apply: /* @__PURE__ */ __name(async (sdk) => {
-      const bedrockAgentCore = sdk.bedrockAgentCoreControl();
-      const currentRuntime = await bedrockAgentCore.getAgentRuntime({
-        agentRuntimeId
-      });
-      if (!currentRuntime.agentRuntimeArtifact) {
-        throw new ToolkitError("RuntimeMissingArtifact", "Current runtime does not have an artifact");
-      }
-      if (!currentRuntime.roleArn) {
-        throw new ToolkitError("RuntimeMissingRoleArn", "Current runtime does not have a roleArn");
-      }
-      if (!currentRuntime.networkConfiguration) {
-        throw new ToolkitError("RuntimeMissingNetworkConfig", "Current runtime does not have a networkConfiguration");
-      }
-      await bedrockAgentCore.updateAgentRuntime({
-        agentRuntimeId,
-        agentRuntimeArtifact: runtimeChange.artifact ? toSdkAgentRuntimeArtifact(runtimeChange.artifact) : currentRuntime.agentRuntimeArtifact,
-        roleArn: currentRuntime.roleArn,
-        networkConfiguration: currentRuntime.networkConfiguration,
-        description: runtimeChange.description ?? currentRuntime.description,
-        authorizerConfiguration: currentRuntime.authorizerConfiguration,
-        requestHeaderConfiguration: currentRuntime.requestHeaderConfiguration,
-        protocolConfiguration: currentRuntime.protocolConfiguration,
-        lifecycleConfiguration: currentRuntime.lifecycleConfiguration,
-        environmentVariables: runtimeChange.environmentVariables ?? currentRuntime.environmentVariables
-      });
-    }, "apply")
-  });
-  return ret;
-}
-async function evaluateBedrockAgentCoreRuntimeProps(hotswappablePropChanges, evaluateCfnTemplate) {
-  const runtimeChange = {};
-  for (const updatedPropName in hotswappablePropChanges) {
-    const updatedProp = hotswappablePropChanges[updatedPropName];
-    switch (updatedPropName) {
-      case "AgentRuntimeArtifact":
-        runtimeChange.artifact = await evaluateAgentRuntimeArtifact(
-          updatedProp.newValue,
-          evaluateCfnTemplate
-        );
-        break;
-      case "Description":
-        runtimeChange.description = await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue);
-        break;
-      case "EnvironmentVariables":
-        runtimeChange.environmentVariables = await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue);
-        break;
-      default:
-        throw new ToolkitError(
-          "UnexpectedHotswapProperty",
-          "Unexpected hotswappable property for BedrockAgentCore Runtime. Please report this at github.com/aws/aws-cdk/issues/new/choose"
-        );
-    }
-  }
-  return runtimeChange;
-}
-async function evaluateAgentRuntimeArtifact(artifactValue, evaluateCfnTemplate) {
-  if (artifactValue.CodeConfiguration) {
-    const codeConfig = artifactValue.CodeConfiguration;
-    const code = codeConfig.Code;
-    const s3Location = code.S3 ? {
-      bucket: await evaluateCfnTemplate.evaluateCfnExpression(code.S3.Bucket),
-      prefix: await evaluateCfnTemplate.evaluateCfnExpression(code.S3.Prefix),
-      versionId: code.S3.VersionId ? await evaluateCfnTemplate.evaluateCfnExpression(code.S3.VersionId) : void 0
-    } : void 0;
-    return {
-      codeConfiguration: {
-        code: s3Location ? { s3: s3Location } : {},
-        runtime: await evaluateCfnTemplate.evaluateCfnExpression(codeConfig.Runtime),
-        entryPoint: await evaluateCfnTemplate.evaluateCfnExpression(codeConfig.EntryPoint)
-      }
-    };
-  }
-  if (artifactValue.ContainerConfiguration) {
-    return {
-      containerConfiguration: {
-        containerUri: await evaluateCfnTemplate.evaluateCfnExpression(
-          artifactValue.ContainerConfiguration.ContainerUri
-        )
-      }
-    };
-  }
-  return void 0;
-}
-function toSdkAgentRuntimeArtifact(artifact) {
-  if (artifact.codeConfiguration) {
-    const code = artifact.codeConfiguration.code.s3 ? { s3: artifact.codeConfiguration.code.s3 } : void 0;
-    return {
-      codeConfiguration: {
-        code,
-        runtime: artifact.codeConfiguration.runtime,
-        entryPoint: artifact.codeConfiguration.entryPoint
-      }
-    };
-  }
-  if (artifact.containerConfiguration) {
-    return {
-      containerConfiguration: artifact.containerConfiguration
-    };
-  }
-  throw new ToolkitError("RuntimeArtifactMissingConfig", "AgentRuntimeArtifact must have either codeConfiguration or containerConfiguration");
-}
-var init_bedrock_agentcore_runtimes = __esm({
-  "../toolkit-lib/lib/api/hotswap/bedrock-agentcore-runtimes.ts"() {
-    "use strict";
-    init_common3();
-    init_toolkit_error();
-    __name(isHotswappableBedrockAgentCoreRuntimeChange, "isHotswappableBedrockAgentCoreRuntimeChange");
-    __name(evaluateBedrockAgentCoreRuntimeProps, "evaluateBedrockAgentCoreRuntimeProps");
-    __name(evaluateAgentRuntimeArtifact, "evaluateAgentRuntimeArtifact");
-    __name(toSdkAgentRuntimeArtifact, "toSdkAgentRuntimeArtifact");
-  }
-});
-
 // ../toolkit-lib/lib/api/hotswap/code-build-projects.ts
 async function isHotswappableCodeBuildProjectChange(logicalId, change, evaluateCfnTemplate) {
   if (change.newValue.Type !== "AWS::CodeBuild::Project") {
@@ -310993,7 +310966,7 @@ async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfn
         const operations = [];
         if (lambdaCodeChange.code !== void 0 || lambdaCodeChange.configurations !== void 0) {
           if (lambdaCodeChange.code !== void 0) {
-            const updateFunctionCodeResponse = await lambda.updateFunctionCode({
+            await lambda.updateFunctionCode({
               FunctionName: functionName,
               S3Bucket: lambdaCodeChange.code.s3Bucket,
               S3Key: lambdaCodeChange.code.s3Key,
@@ -311001,7 +310974,7 @@ async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfn
               ZipFile: lambdaCodeChange.code.functionCodeZip,
               S3ObjectVersion: lambdaCodeChange.code.s3ObjectVersion
             });
-            await waitForLambdasPropertiesUpdateToFinish(updateFunctionCodeResponse, lambda, functionName);
+            await waitForLambdasPropertiesUpdateToFinish(lambda, functionName);
           }
           if (lambdaCodeChange.configurations !== void 0) {
             const updateRequest = {
@@ -311013,8 +310986,8 @@ async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfn
             if (lambdaCodeChange.configurations.environment !== void 0) {
               updateRequest.Environment = lambdaCodeChange.configurations.environment;
             }
-            const updateFunctionCodeResponse = await lambda.updateFunctionConfiguration(updateRequest);
-            await waitForLambdasPropertiesUpdateToFinish(updateFunctionCodeResponse, lambda, functionName);
+            await lambda.updateFunctionConfiguration(updateRequest);
+            await waitForLambdasPropertiesUpdateToFinish(lambda, functionName);
           }
           const versions = dependencies.filter((d6) => d6.resourceType === "AWS::Lambda::Version");
           if (versions.length) {
@@ -311132,10 +311105,10 @@ function zipString(fileName, rawString) {
     void archive.finalize();
   });
 }
-async function waitForLambdasPropertiesUpdateToFinish(currentFunctionConfiguration, lambda, functionName) {
-  const functionIsInVpcOrUsesDockerForCode = currentFunctionConfiguration.VpcConfig?.VpcId || currentFunctionConfiguration.PackageType === "Image";
-  const delaySeconds = functionIsInVpcOrUsesDockerForCode ? 5 : 1;
-  await lambda.waitUntilFunctionUpdated(delaySeconds, {
+async function waitForLambdasPropertiesUpdateToFinish(lambda, functionName) {
+  const minDelaySeconds = 1;
+  const maxDelaySeconds = 10;
+  await lambda.waitUntilFunctionUpdated(minDelaySeconds, maxDelaySeconds, {
     FunctionName: functionName
   });
 }
@@ -311301,50 +311274,99 @@ var init_s3_bucket_deployments = __esm({
   }
 });
 
-// ../toolkit-lib/lib/api/hotswap/stepfunctions-state-machines.ts
-async function isHotswappableStateMachineChange(logicalId, change, evaluateCfnTemplate) {
-  if (change.newValue.Type !== "AWS::StepFunctions::StateMachine") {
-    return [];
-  }
+// ../toolkit-lib/lib/api/hotswap/cloud-control-resource.ts
+async function isHotswappableCloudControlChange(logicalId, change, evaluateCfnTemplate, _hotswapPropertyOverrides) {
   const ret = [];
-  const classifiedChanges = classifyChanges(change, ["DefinitionString"]);
+  const changedPropNames = Object.keys(change.propertyUpdates);
+  if (changedPropNames.length === 0) {
+    return ret;
+  }
+  const classifiedChanges = classifyChanges(change, changedPropNames);
   classifiedChanges.reportNonHotswappablePropertyChanges(ret);
-  const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
-  if (namesOfHotswappableChanges.length > 0) {
-    const stateMachineNameInCfnTemplate = change.newValue?.Properties?.StateMachineName;
-    const stateMachineArn = stateMachineNameInCfnTemplate ? await evaluateCfnTemplate.evaluateCfnExpression({
-      "Fn::Sub": "arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:" + stateMachineNameInCfnTemplate
-    }) : await evaluateCfnTemplate.findPhysicalNameFor(logicalId);
-    if (!stateMachineArn) {
-      return ret;
+  if (classifiedChanges.namesOfHotswappableProps.length === 0) {
+    return ret;
+  }
+  const resourceType = change.newValue.Type;
+  const identifier = await resolveCloudControlIdentifier(logicalId, resourceType, evaluateCfnTemplate);
+  if (!identifier) {
+    ret.push(nonHotswappableChange(
+      change,
+      "resource-unsupported" /* RESOURCE_UNSUPPORTED */,
+      "Could not determine the physical name or primary identifier of the resource, so Cloud Control API cannot hotswap it."
+    ));
+    return ret;
+  }
+  const evaluatedProps = {};
+  for (const propName of classifiedChanges.namesOfHotswappableProps) {
+    try {
+      evaluatedProps[propName] = await evaluateCfnTemplate.evaluateCfnExpression(
+        change.propertyUpdates[propName].newValue
+      );
+    } catch (e6) {
+      if (e6 instanceof CfnEvaluationException) {
+        ret.push(nonHotswappableChange(
+          change,
+          "resource-unsupported" /* RESOURCE_UNSUPPORTED */,
+          `Property '${propName}' of resource '${logicalId}' has been replaced and could not be resolved: ${e6.message}`
+        ));
+        return ret;
+      }
+      throw e6;
     }
-    ret.push({
-      change: {
-        cause: change,
-        resources: [{
-          logicalId,
-          resourceType: change.newValue.Type,
-          physicalName: stateMachineArn?.split(":")[6],
-          metadata: evaluateCfnTemplate.metadataFor(logicalId)
-        }]
-      },
-      hotswappable: true,
-      service: "stepfunctions-service",
-      apply: /* @__PURE__ */ __name(async (sdk) => {
-        await sdk.stepFunctions().updateStateMachine({
-          stateMachineArn,
-          definition: await evaluateCfnTemplate.evaluateCfnExpression(change.propertyUpdates.DefinitionString.newValue)
-        });
-      }, "apply")
-    });
   }
+  ret.push({
+    change: {
+      cause: change,
+      resources: [{
+        logicalId,
+        resourceType,
+        physicalName: identifier,
+        metadata: evaluateCfnTemplate.metadataFor(logicalId)
+      }]
+    },
+    hotswappable: true,
+    service: "cloudcontrol",
+    apply: /* @__PURE__ */ __name(async (sdk) => {
+      const cloudControl = sdk.cloudControl();
+      const patchOps = [];
+      for (const propName of classifiedChanges.namesOfHotswappableProps) {
+        const diff = change.propertyUpdates[propName];
+        const newValue = evaluatedProps[propName];
+        if (diff.isRemoval) {
+          patchOps.push({ op: "remove", path: `/${propName}` });
+        } else if (diff.isAddition) {
+          patchOps.push({ op: "add", path: `/${propName}`, value: newValue });
+        } else {
+          patchOps.push({ op: "replace", path: `/${propName}`, value: newValue });
+        }
+      }
+      if (patchOps.length === 0) {
+        return;
+      }
+      await cloudControl.updateResource({
+        TypeName: resourceType,
+        Identifier: identifier,
+        PatchDocument: JSON.stringify(patchOps)
+      });
+    }, "apply")
+  });
   return ret;
 }
-var init_stepfunctions_state_machines = __esm({
-  "../toolkit-lib/lib/api/hotswap/stepfunctions-state-machines.ts"() {
+async function resolveCloudControlIdentifier(logicalId, resourceType, evaluateCfnTemplate) {
+  const cfnPhysicalId = await evaluateCfnTemplate.findPhysicalNameFor(logicalId);
+  if (!cfnPhysicalId) {
+    return void 0;
+  }
+  return evaluateCfnTemplate.evaluateCloudControlIdentifier(logicalId, resourceType, cfnPhysicalId);
+}
+var init_cloud_control_resource = __esm({
+  "../toolkit-lib/lib/api/hotswap/cloud-control-resource.ts"() {
     "use strict";
     init_common3();
-    __name(isHotswappableStateMachineChange, "isHotswappableStateMachineChange");
+    init_payloads();
+    init_cloudformation2();
+    __name(isHotswappableCloudControlChange, "isHotswappableCloudControlChange");
+    __name(resolveCloudControlIdentifier, "resolveCloudControlIdentifier");
   }
 });
 
@@ -311560,6 +311582,8 @@ async function classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, n
   const promises3 = [];
   const hotswappableResources = new Array();
   const nonHotswappableResources = new Array();
+  const nestedStackTasks = [];
+  const limit = pLimit2(10);
   for (const logicalId of Object.keys(stackChanges.outputs.changes)) {
     nonHotswappableResources.push({
       hotswappable: false,
@@ -311576,16 +311600,14 @@ async function classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, n
   }
   for (const [logicalId, change] of Object.entries(resourceDifferences)) {
     if (change.newValue?.Type === "AWS::CloudFormation::Stack" && change.oldValue?.Type === "AWS::CloudFormation::Stack") {
-      const nestedHotswappableResources = await findNestedHotswappableChanges(
+      nestedStackTasks.push(limit(() => findNestedHotswappableChanges(
         logicalId,
         change,
         nestedStackNames,
         evaluateCfnTemplate,
         sdk,
         hotswapPropertyOverrides
-      );
-      hotswappableResources.push(...nestedHotswappableResources.hotswappable);
-      nonHotswappableResources.push(...nestedHotswappableResources.nonHotswappable);
+      )));
       continue;
     }
     const hotswappableChangeCandidate = isCandidateForHotswapping(logicalId, change, evaluateCfnTemplate);
@@ -311604,9 +311626,14 @@ async function classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, n
       nonHotswappableResources.push(nonHotswappableResource(hotswappableChangeCandidate));
     }
   }
+  const nestedResults = await Promise.all(nestedStackTasks);
+  for (const nested of nestedResults) {
+    hotswappableResources.push(...nested.hotswappable);
+    nonHotswappableResources.push(...nested.nonHotswappable);
+  }
   const changesDetectionResults = [];
-  for (const detectorResultPromises of promises3) {
-    const hotswapDetectionResults = await Promise.all(await detectorResultPromises());
+  const detectorResults = await Promise.all(promises3.map((fn) => limit(fn)));
+  for (const hotswapDetectionResults of detectorResults) {
     changesDetectionResults.push(hotswapDetectionResults);
   }
   for (const resourceDetectionResults of changesDetectionResults) {
@@ -311876,16 +311903,15 @@ var init_hotswap_deployments = __esm({
     init_util();
     init_cloudformation2();
     init_appsync_mapping_templates();
-    init_bedrock_agentcore_runtimes();
     init_code_build_projects();
     init_common3();
     init_ecs_services();
     init_lambda_functions();
     init_s3_bucket_deployments();
-    init_stepfunctions_state_machines();
     init_toolkit_error();
     init_private();
     init_plugin2();
+    init_cloud_control_resource();
     pLimit2 = require_p_limit();
     RESOURCE_DETECTORS = {
       // Lambda
@@ -311897,10 +311923,8 @@ var init_hotswap_deployments = __esm({
       "AWS::AppSync::FunctionConfiguration": isHotswappableAppSyncChange,
       "AWS::AppSync::GraphQLSchema": isHotswappableAppSyncChange,
       "AWS::AppSync::ApiKey": isHotswappableAppSyncChange,
-      "AWS::BedrockAgentCore::Runtime": isHotswappableBedrockAgentCoreRuntimeChange,
       "AWS::ECS::TaskDefinition": isHotswappableEcsServiceChange,
       "AWS::CodeBuild::Project": isHotswappableCodeBuildProjectChange,
-      "AWS::StepFunctions::StateMachine": isHotswappableStateMachineChange,
       "Custom::CDKBucketDeployment": isHotswappableS3BucketDeploymentChange,
       "AWS::IAM::Policy": /* @__PURE__ */ __name(async (logicalId, change, evaluateCfnTemplate) => {
         if (await skipChangeForS3DeployCustomResourcePolicy(logicalId, change, evaluateCfnTemplate)) {
@@ -311908,7 +311932,23 @@ var init_hotswap_deployments = __esm({
         }
         return [nonHotswappableResource(change)];
       }, "AWS::IAM::Policy"),
-      "AWS::CDK::Metadata": /* @__PURE__ */ __name(async () => [], "AWS::CDK::Metadata")
+      "AWS::CDK::Metadata": /* @__PURE__ */ __name(async () => [], "AWS::CDK::Metadata"),
+      // Resources that use CCAPIS
+      "AWS::ApiGateway::RestApi": isHotswappableCloudControlChange,
+      "AWS::ApiGateway::Deployment": isHotswappableCloudControlChange,
+      "AWS::ApiGateway::Method": isHotswappableCloudControlChange,
+      "AWS::ApiGatewayV2::Api": isHotswappableCloudControlChange,
+      "AWS::ApiGatewayV2::Integration": isHotswappableCloudControlChange,
+      "AWS::Bedrock::Agent": isHotswappableCloudControlChange,
+      "AWS::Events::Rule": isHotswappableCloudControlChange,
+      "AWS::DynamoDB::Table": isHotswappableCloudControlChange,
+      "AWS::DynamoDB::GlobalTable": isHotswappableCloudControlChange,
+      "AWS::SQS::Queue": isHotswappableCloudControlChange,
+      "AWS::CloudWatch::Alarm": isHotswappableCloudControlChange,
+      "AWS::CloudWatch::CompositeAlarm": isHotswappableCloudControlChange,
+      "AWS::CloudWatch::Dashboard": isHotswappableCloudControlChange,
+      "AWS::StepFunctions::StateMachine": isHotswappableCloudControlChange,
+      "AWS::BedrockAgentCore::Runtime": isHotswappableCloudControlChange
     };
     __name(tryHotswapDeployment, "tryHotswapDeployment");
     __name(hotswapDeployment, "hotswapDeployment");

package/package.json

@@ -66,11 +66,11 @@
     "@aws-cdk/aws-service-spec": "^0.1.171",
     "@aws-cdk/cdk-assets-lib": "1.4.3",
     "@aws-cdk/cloud-assembly-api": "2.2.2",
-    "@aws-cdk/cloud-assembly-schema": ">=53.15.0",
+    "@aws-cdk/cloud-assembly-schema": ">=53.16.0",
     "@aws-cdk/cloudformation-diff": "2.187.1",
-    "@aws-cdk/toolkit-lib": "1.21.3",
+    "@aws-cdk/toolkit-lib": "1.22.0",
     "@aws-sdk/client-cloudformation": "^3",
-    "aws-cdk": "2.1118.1",
+    "aws-cdk": "2.1118.2",
     "chalk": "^4",
     "chokidar": "^4",
     "fs-extra": "^11",
@@ -80,7 +80,7 @@
   },
   "dependencies": {
     "@aws-cdk/aws-service-spec": "0.1.171",
-    "aws-cdk": "2.1118.1"
+    "aws-cdk": "2.1118.2"
   },
   "keywords": [
     "aws",
@@ -102,7 +102,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.197.14",
+  "version": "2.197.15",
   "packageManager": "yarn@4.13.0",
   "types": "lib/index.d.ts",
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"yarn projen\"."