@aws-cdk/integ-runner 2.197.14 → 2.197.16

package/THIRD_PARTY_LICENSES

@@ -21278,7 +21278,7 @@ THE SOFTWARE.
 
 ----------------
 
-** basic-ftp@5.2.2 - https://www.npmjs.com/package/basic-ftp/v/5.2.2 | MIT
+** basic-ftp@5.3.0 - https://www.npmjs.com/package/basic-ftp/v/5.3.0 | MIT
 Copyright (c) 2019 Patrick Juchli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

package/lib/workers/extract/index.js

@@ -1287,6 +1287,8 @@ var init_metadata_schema = __esm({
       ArtifactMetadataEntryType8["LOGICAL_ID"] = "aws:cdk:logicalId";
       ArtifactMetadataEntryType8["STACK_TAGS"] = "aws:cdk:stack-tags";
       ArtifactMetadataEntryType8["DO_NOT_REFACTOR"] = "aws:cdk:do-not-refactor";
+      ArtifactMetadataEntryType8["CREATION_STACK"] = "aws:cdk:creationStack";
+      ArtifactMetadataEntryType8["PROPERTY_ASSIGNMENT"] = "aws:cdk:propertyAssignment";
       return ArtifactMetadataEntryType8;
     })(ArtifactMetadataEntryType || {});
   }
@@ -4670,7 +4672,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.3" };
   }
 });
 
@@ -5095,12 +5097,22 @@ have a unique display name. (Default - no display name)`,
                 {
                   $ref: "#/definitions/ContainerImageAssetMetadataEntry"
                 },
+                {
+                  $ref: "#/definitions/PropertyMutationMetadataEntry"
+                },
                 {
                   type: "array",
                   items: {
                     $ref: "#/definitions/Tag"
                   }
                 },
+                {
+                  description: "Type of creation stack data",
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
                 {
                   type: [
                     "string",
@@ -5296,6 +5308,27 @@ have a unique display name. (Default - no display name)`,
             "type"
           ]
         },
+        PropertyMutationMetadataEntry: {
+          description: "Metadata type of a PropertyMutation",
+          type: "object",
+          properties: {
+            propertyName: {
+              description: "Name of the property",
+              type: "string"
+            },
+            stackTrace: {
+              description: "Stack trace of the mutation",
+              type: "array",
+              items: {
+                type: "string"
+              }
+            }
+          },
+          required: [
+            "propertyName",
+            "stackTrace"
+          ]
+        },
         Tag: {
           description: "Metadata Entry spec for stack tag.",
           type: "object",
@@ -6676,7 +6709,7 @@ var require_integ_schema = __commonJS({
 var require_version = __commonJS({
   "../cloud-assembly-schema/schema/version.json"(exports2, module2) {
     module2.exports = {
-      schemaHash: "25d8ad154190878ec8a9e970fa21a0e182fa834304913d43be86f9b0613271f5",
+      schemaHash: "794dc834654646b4a60c6d8ea46ed0245a71de33e598289f6922082951768d04",
       $comment: "Do not hold back the version on additions: jsonschema validation of the manifest by the consumer will trigger errors on unexpected fields.",
       revision: 53
     };
@@ -112855,7 +112888,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 +112951,7 @@ var require_dist_cjs56 = __commonJS({
       GetResourceRequestStatusCommand,
       ListResourceRequestsCommand,
       ListResourcesCommand: ListResourcesCommand2,
-      UpdateResourceCommand
+      UpdateResourceCommand: UpdateResourceCommand2
     };
     var paginators = {
       paginateListResourceRequests,
@@ -112979,7 +113012,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 +118676,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 +119974,7 @@ var require_dist_cjs57 = __commonJS({
       DescribeStacksCommand: DescribeStacksCommand2,
       DescribeStackSetCommand,
       DescribeStackSetOperationCommand,
-      DescribeTypeCommand,
+      DescribeTypeCommand: DescribeTypeCommand2,
       DescribeTypeRegistrationCommand,
       DetectStackDriftCommand: DetectStackDriftCommand2,
       DetectStackResourceDriftCommand: DetectStackResourceDriftCommand2,
@@ -120622,7 +120655,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 +285249,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 +285276,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 +285458,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 +292048,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 +292134,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 +292153,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 +292292,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 +292413,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 +292463,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 +310711,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 +310999,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 +311007,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 +311019,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 +311138,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 +311307,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 +311615,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 +311633,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 +311659,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 +311936,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 +311956,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 +311965,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");
@@ -313745,12 +313818,19 @@ function resourceMoves(before, after, direction = "direct", ignoreModifications
   const digestsAfter = resourceDigests(after, direction);
   if (!(ignoreModifications || isomorphic(digestsBefore, digestsAfter))) {
     const message2 = ["A refactor operation cannot add, remove or update resources. Only resource moves and renames are allowed."];
-    const difference2 = /* @__PURE__ */ __name((a6, b6) => {
-      return Array.from(setDiff(new Set(Object.keys(a6)), new Set(Object.keys(b6)))).flatMap((k6) => a6[k6]).map((x6) => `  - ${x6.toPath()}`).sort().join("\n");
-    }, "difference");
+    const locationsForDigests = /* @__PURE__ */ __name((a6, b6) => {
+      return Array.from(setDiff(new Set(Object.keys(a6)), new Set(Object.keys(b6)))).flatMap((k6) => a6[k6]);
+    }, "locationsForDigests");
+    const formatList = /* @__PURE__ */ __name((locs, icon) => locs.map((x6) => `  [${icon}] ${x6.toPath()}`).sort().join("\n"), "formatList");
     const stackNames = /* @__PURE__ */ __name((stacks) => stacks.length === 0 ? "NONE" : stacks.map((s6) => s6.stackName).sort().join(", "), "stackNames");
-    const onlyDeployed = difference2(digestsBefore, digestsAfter);
-    const onlyLocal = difference2(digestsAfter, digestsBefore);
+    const onlyDeployedLocs = locationsForDigests(digestsBefore, digestsAfter);
+    const onlyLocalLocs = locationsForDigests(digestsAfter, digestsBefore);
+    const onlyDeployedPaths = new Set(onlyDeployedLocs.map((l6) => l6.toPath()));
+    const onlyLocalPaths = new Set(onlyLocalLocs.map((l6) => l6.toPath()));
+    const differentPaths = new Set(Array.from(onlyDeployedPaths).filter((p6) => onlyLocalPaths.has(p6)));
+    const onlyDeployed = formatList(onlyDeployedLocs.filter((l6) => !differentPaths.has(l6.toPath())), "-");
+    const onlyLocal = formatList(onlyLocalLocs.filter((l6) => !differentPaths.has(l6.toPath())), "+");
+    const different = formatList([...onlyDeployedLocs, ...onlyLocalLocs].filter((l6) => differentPaths.has(l6.toPath())), "~");
     if (onlyDeployed.length > 0) {
       message2.push(`The following resources are present only in the AWS environment:
 ${onlyDeployed}`);
@@ -313759,6 +313839,11 @@ ${onlyDeployed}`);
       message2.push(`
 The following resources are present only in your CDK application:
 ${onlyLocal}`);
+    }
+    if (different.length > 0) {
+      message2.push(`
+The following resources are different in your CDK application and the AWS environment:
+${different}`);
     }
     message2.push("");
     message2.push("The following stacks were used in the comparison:");
@@ -317106,11 +317191,6 @@ var init_toolkit = __esm({
             deploymentMethod: options.deploymentMethod,
             cleanupOnNoOp: isExecutingChangeSetDeployment(options.deploymentMethod)
           }) : void 0;
-          if (prepareResult?.noOp === true) {
-            await ioHelper.notify(IO.CDK_TOOLKIT_I5900.msg(chalk23.green(`
- \u2705  ${stack.displayName} (no changes)`), prepareResult));
-            return;
-          }
           const formatter = new DiffFormatter({
             templateInfo: {
               oldTemplate: currentTemplate,
@@ -317148,7 +317228,7 @@ Do you wish to deploy these changes`;
           deploySpan.incCounter("resources", resourceCount);
           let deployDuration;
           try {
-            const prepareIsFinal = isNonExecutingChangeSetDeployment(options.deploymentMethod);
+            const prepareIsFinal = prepareResult && (prepareResult.noOp || isNonExecutingChangeSetDeployment(options.deploymentMethod));
             let deployResult = prepareIsFinal ? prepareResult : void 0;
             let rollback = options.rollback;
             let iteration = 0;
@@ -317229,10 +317309,9 @@ ${deployResult.stackArn}`));
               hierarchicalId: stack.hierarchicalId
             });
           } catch (e6) {
-            throw new ToolkitError(
-              "DeployStackFailed",
-              [`\u274C  ${chalk23.bold(stack.stackName)} failed:`, ...e6.name ? [`${e6.name}:`] : [], e6.message].join(" ")
-            );
+            const code = ToolkitError.isToolkitError(e6) ? e6.name : "DeployStackFailed";
+            const newMessage = [`\u274C  ${chalk23.bold(stack.stackName)} failed:`, ...e6.name ? [`${e6.name}:`] : [], e6.message].join(" ");
+            throw new ToolkitError(code, newMessage);
           } finally {
             if (options.traceLogs) {
               const cloudWatchLogMonitor = options.cloudWatchLogMonitor ?? new CloudWatchLogEventMonitor({ ioHelper });
@@ -325023,6 +325102,61 @@ Closing reason: ${this._closingError.stack}`;
   }
 });
 
+// ../../../node_modules/basic-ftp/dist/netUtils.js
+var require_netUtils = __commonJS({
+  "../../../node_modules/basic-ftp/dist/netUtils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.describeTLS = describeTLS;
+    exports2.describeAddress = describeAddress;
+    exports2.upgradeSocket = upgradeSocket;
+    exports2.ipIsPrivateV4Address = ipIsPrivateV4Address;
+    var tls_1 = require("tls");
+    function describeTLS(socket) {
+      if (socket instanceof tls_1.TLSSocket) {
+        const protocol = socket.getProtocol();
+        return protocol ? protocol : "Server socket or disconnected client socket";
+      }
+      return "No encryption";
+    }
+    __name(describeTLS, "describeTLS");
+    function describeAddress(socket) {
+      if (socket.remoteFamily === "IPv6") {
+        return `[${socket.remoteAddress}]:${socket.remotePort}`;
+      }
+      return `${socket.remoteAddress}:${socket.remotePort}`;
+    }
+    __name(describeAddress, "describeAddress");
+    function upgradeSocket(socket, options) {
+      return new Promise((resolve13, reject) => {
+        const tlsOptions = Object.assign({}, options, {
+          socket
+        });
+        const tlsSocket = (0, tls_1.connect)(tlsOptions, () => {
+          const expectCertificate = tlsOptions.rejectUnauthorized !== false;
+          if (expectCertificate && !tlsSocket.authorized) {
+            reject(tlsSocket.authorizationError);
+          } else {
+            tlsSocket.removeAllListeners("error");
+            resolve13(tlsSocket);
+          }
+        }).once("error", (error4) => {
+          reject(error4);
+        });
+      });
+    }
+    __name(upgradeSocket, "upgradeSocket");
+    function ipIsPrivateV4Address(ip = "") {
+      if (ip.startsWith("::ffff:")) {
+        ip = ip.substr(7);
+      }
+      const octets = ip.split(".").map((o6) => parseInt(o6, 10));
+      return octets[0] === 10 || octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 192 && octets[1] === 168 || ip === "127.0.0.1";
+    }
+    __name(ipIsPrivateV4Address, "ipIsPrivateV4Address");
+  }
+});
+
 // ../../../node_modules/basic-ftp/dist/FileInfo.js
 var require_FileInfo = __commonJS({
   "../../../node_modules/basic-ftp/dist/FileInfo.js"(exports2) {
@@ -325559,81 +325693,33 @@ var require_StringWriter = __commonJS({
       static {
         __name(this, "StringWriter");
       }
-      constructor() {
-        super(...arguments);
-        this.buf = Buffer.alloc(0);
+      constructor(maxByteLength = 1 * 1024 * 1024) {
+        super();
+        this.maxByteLength = maxByteLength;
+        this.byteLength = 0;
+        this.bufs = [];
       }
       _write(chunk, _2, callback) {
-        if (chunk instanceof Buffer) {
-          this.buf = Buffer.concat([this.buf, chunk]);
-          callback(null);
-        } else {
-          callback(new Error("StringWriter expects chunks of type 'Buffer'."));
+        if (!(chunk instanceof Buffer)) {
+          callback(new Error("StringWriter: expects chunks of type 'Buffer'."));
+          return;
+        }
+        if (this.byteLength + chunk.byteLength > this.maxByteLength) {
+          callback(new Error(`StringWriter: Maximum bytes exceeded, maxByteLength=${this.maxByteLength}.`));
+          return;
         }
+        this.byteLength += chunk.byteLength;
+        this.bufs.push(chunk);
+        callback(null);
       }
       getText(encoding) {
-        return this.buf.toString(encoding);
+        return Buffer.concat(this.bufs).toString(encoding);
       }
     };
     exports2.StringWriter = StringWriter;
   }
 });
 
-// ../../../node_modules/basic-ftp/dist/netUtils.js
-var require_netUtils = __commonJS({
-  "../../../node_modules/basic-ftp/dist/netUtils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.describeTLS = describeTLS;
-    exports2.describeAddress = describeAddress;
-    exports2.upgradeSocket = upgradeSocket;
-    exports2.ipIsPrivateV4Address = ipIsPrivateV4Address;
-    var tls_1 = require("tls");
-    function describeTLS(socket) {
-      if (socket instanceof tls_1.TLSSocket) {
-        const protocol = socket.getProtocol();
-        return protocol ? protocol : "Server socket or disconnected client socket";
-      }
-      return "No encryption";
-    }
-    __name(describeTLS, "describeTLS");
-    function describeAddress(socket) {
-      if (socket.remoteFamily === "IPv6") {
-        return `[${socket.remoteAddress}]:${socket.remotePort}`;
-      }
-      return `${socket.remoteAddress}:${socket.remotePort}`;
-    }
-    __name(describeAddress, "describeAddress");
-    function upgradeSocket(socket, options) {
-      return new Promise((resolve13, reject) => {
-        const tlsOptions = Object.assign({}, options, {
-          socket
-        });
-        const tlsSocket = (0, tls_1.connect)(tlsOptions, () => {
-          const expectCertificate = tlsOptions.rejectUnauthorized !== false;
-          if (expectCertificate && !tlsSocket.authorized) {
-            reject(tlsSocket.authorizationError);
-          } else {
-            tlsSocket.removeAllListeners("error");
-            resolve13(tlsSocket);
-          }
-        }).once("error", (error4) => {
-          reject(error4);
-        });
-      });
-    }
-    __name(upgradeSocket, "upgradeSocket");
-    function ipIsPrivateV4Address(ip = "") {
-      if (ip.startsWith("::ffff:")) {
-        ip = ip.substr(7);
-      }
-      const octets = ip.split(".").map((o6) => parseInt(o6, 10));
-      return octets[0] === 10 || octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 192 && octets[1] === 168 || ip === "127.0.0.1";
-    }
-    __name(ipIsPrivateV4Address, "ipIsPrivateV4Address");
-  }
-});
-
 // ../../../node_modules/basic-ftp/dist/transfer.js
 var require_transfer2 = __commonJS({
   "../../../node_modules/basic-ftp/dist/transfer.js"(exports2) {
@@ -325909,13 +325995,13 @@ var require_Client = __commonJS({
     var tls_1 = require("tls");
     var util_1 = require("util");
     var FtpContext_1 = require_FtpContext();
+    var netUtils_1 = require_netUtils();
+    var parseControlResponse_1 = require_parseControlResponse();
     var parseList_1 = require_parseList();
+    var parseListMLSD_1 = require_parseListMLSD();
     var ProgressTracker_1 = require_ProgressTracker();
     var StringWriter_1 = require_StringWriter();
-    var parseListMLSD_1 = require_parseListMLSD();
-    var netUtils_1 = require_netUtils();
     var transfer_1 = require_transfer2();
-    var parseControlResponse_1 = require_parseControlResponse();
     var fsReadDir = (0, util_1.promisify)(fs_1.readdir);
     var fsMkDir = (0, util_1.promisify)(fs_1.mkdir);
     var fsStat = (0, util_1.promisify)(fs_1.stat);
@@ -325923,7 +326009,8 @@ var require_Client = __commonJS({
     var fsClose = (0, util_1.promisify)(fs_1.close);
     var fsUnlink = (0, util_1.promisify)(fs_1.unlink);
     var defaultClientOptions = {
-      allowSeparateTransferHost: true
+      allowSeparateTransferHost: true,
+      maxListingBytes: 40 * 1024 * 1024
     };
     var LIST_COMMANDS_DEFAULT = /* @__PURE__ */ __name(() => ["LIST -a", "LIST"], "LIST_COMMANDS_DEFAULT");
     var LIST_COMMANDS_MLSD = /* @__PURE__ */ __name(() => ["MLSD", "LIST -a", "LIST"], "LIST_COMMANDS_MLSD");
@@ -325936,13 +326023,15 @@ var require_Client = __commonJS({
        *
        * @param timeout  Timeout in milliseconds, use 0 for no timeout. Optional, default is 30 seconds.
        */
-      constructor(timeout = 3e4, options = defaultClientOptions) {
+      constructor(timeout = 3e4, userOptions = defaultClientOptions) {
         this.availableListCommands = LIST_COMMANDS_DEFAULT();
+        const options = { ...defaultClientOptions, ...userOptions };
         this.ftp = new FtpContext_1.FTPContext(timeout);
         this.prepareTransfer = this._enterFirstCompatibleMode([
           transfer_1.enterPassiveModeIPv6,
           options.allowSeparateTransferHost ? transfer_1.enterPassiveModeIPv4 : transfer_1.enterPassiveModeIPv4_forceControlHostIP
         ]);
+        this.options = options;
         this.parseList = parseList_1.parseList;
         this._progressTracker = new ProgressTracker_1.ProgressTracker();
       }
@@ -326379,7 +326468,7 @@ var require_Client = __commonJS({
        * @protected
        */
       async _requestListWithCommand(command) {
-        const buffer = new StringWriter_1.StringWriter();
+        const buffer = new StringWriter_1.StringWriter(this.options.maxListingBytes);
         await (0, transfer_1.downloadTo)(buffer, {
           ftp: this.ftp,
           tracker: this._progressTracker,

package/package.json

@@ -64,13 +64,13 @@
     "ts-jest": "^29.4.9",
     "typescript": "5.9",
     "@aws-cdk/aws-service-spec": "^0.1.171",
-    "@aws-cdk/cdk-assets-lib": "1.4.3",
+    "@aws-cdk/cdk-assets-lib": "1.4.4",
     "@aws-cdk/cloud-assembly-api": "2.2.2",
-    "@aws-cdk/cloud-assembly-schema": ">=53.15.0",
+    "@aws-cdk/cloud-assembly-schema": ">=53.17.0",
     "@aws-cdk/cloudformation-diff": "2.187.1",
-    "@aws-cdk/toolkit-lib": "1.21.3",
+    "@aws-cdk/toolkit-lib": "1.22.1",
     "@aws-sdk/client-cloudformation": "^3",
-    "aws-cdk": "2.1118.1",
+    "aws-cdk": "2.1118.3",
     "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.3"
   },
   "keywords": [
     "aws",
@@ -102,7 +102,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.197.14",
+  "version": "2.197.16",
   "packageManager": "yarn@4.13.0",
   "types": "lib/index.d.ts",
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"yarn projen\"."