konokenj.cdk-api-mcp-server 0.42.0__py3-none-any.whl → 0.44.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/README.md

@@ -108,8 +108,8 @@ With the `@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion` disabled, the runt
 
 ## Lock file
 
-The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or
-`package-lock.json`). When bundling in a Docker container, the path containing this lock file is
+The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb`,
+`bun.lock` or `package-lock.json`). When bundling in a Docker container, the path containing this lock file is
 used as the source (`/asset-input`) for the volume mounted in the container.
 
 By default, the construct will try to automatically determine your project lock file.
@@ -201,7 +201,7 @@ new nodejs.NodejsFunction(this, 'my-handler', {
 
 The modules listed in `nodeModules` must be present in the `package.json`'s dependencies or
 installed. The same version will be used for installation. The lock file (`yarn.lock`,
-`pnpm-lock.yaml`, `bun.lockb` or `package-lock.json`) will be used along with the right installer (`yarn`,
+`pnpm-lock.yaml`, `bun.lockb`, `bun.lock` or `package-lock.json`) will be used along with the right installer (`yarn`,
 `pnpm`, `bun` or `npm`).
 
 When working with `nodeModules` using native dependencies, you might want to force bundling in a

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/integ.dependencies-bun-lock.ts

@@ -0,0 +1,50 @@
+import * as path from 'path';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new cdk.Stack(app, 'TestStack');
+
+const handler = new lambda.NodejsFunction(stack, 'Function', {
+  entry: path.join(__dirname, 'integ-handlers/bun_lock/dependencies-bun.ts'),
+  runtime: Runtime.NODEJS_22_X,
+  bundling: {
+    minify: true,
+    // Will be installed, not bundled
+    // (axios is a package with sub-dependencies,
+    // will be used to ensure bun bundling works as expected)
+    nodeModules: ['axios'],
+    forceDockerBundling: true,
+  },
+
+  // To (re-)generate this lockfile:
+  // 1. Ensure your local version of bun matches the version in packages/aws-cdk-lib/aws-lambda-nodejs/lib/Dockerfile
+  // 2. `cd` to `packages/@aws-cdk-testing/framework-integ/test/aws-lambda-nodejs/test/integ-handlers/bun`
+  // 3. Rename the `_package.json` file to `package.json`
+  // 4. Run `bun install`
+  depsLockFilePath: path.join(__dirname, 'integ-handlers/bun_lock/bun.lock'),
+});
+
+const integ = new IntegTest(app, 'BunTest', {
+  testCases: [stack],
+  stackUpdateWorkflow: false, // this will tell the runner to not check in assets.
+});
+
+const response = integ.assertions.invokeFunction({
+  functionName: handler.functionName,
+});
+response.expect(
+  ExpectedResult.objectLike({
+    // expect invoking without error
+    StatusCode: 200,
+    ExecutedVersion: '$LATEST',
+    Payload: 'null',
+  }),
+);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/README.md

@@ -418,6 +418,24 @@ To apply changes of the cluster, such as engine version, in the next scheduled m
 
 For details, see [Modifying an Amazon Aurora DB cluster](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Modifying.html).
 
+### Retaining Automated Backups
+
+By default, when a database cluster is deleted, automated backups are removed immediately unless an AWS Backup policy specifies a point-in-time restore rule. You can control this behavior using the `deleteAutomatedBackups` property:
+
+```ts
+declare const vpc: ec2.IVpc;
+// Retain automated backups after cluster deletion
+new rds.DatabaseCluster(this, 'Database', {
+  engine: rds.DatabaseClusterEngine.auroraMysql({ version: rds.AuroraMysqlEngineVersion.VER_3_01_0 }),
+  writer: rds.ClusterInstance.provisioned('writer'),
+  vpc,
+  deleteAutomatedBackups: false,
+});
+```
+
+When set to `false`, automated backups are retained according to the configured retention period after the cluster is deleted. When set to `true` or not specified (default), automated backups are deleted immediately when the cluster is deleted.
+Detail about this feature can be found in the [AWS documentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Managing.Backups.Retaining.html).
+
 ### Migrating from instanceProps
 
 Creating instances in a `DatabaseCluster` using `instanceProps` & `instances` is
@@ -1148,6 +1166,26 @@ const proxy = dbInstance.addProxy('proxy', {
 });
 ```
 
+### Proxy Endpoint
+The following example add additional endpoint to RDS Proxy.
+
+```ts
+declare const vpc: ec2.Vpc;
+declare const secrets: secretsmanager.Secret[];
+declare const dbInstance: rds.DatabaseInstance;
+
+const proxy = dbInstance.addProxy('Proxy', {
+  secrets,
+  vpc,
+});
+
+// Add a reader endpoint
+proxy.addEndpoint('ProxyEndpoint', {
+  vpc,
+  targetRole: rds.ProxyEndpointTargetRole.READ_ONLY,
+});
+```
+
 ## Exporting Logs
 
 You can publish database logs to Amazon CloudWatch Logs. With CloudWatch Logs, you can perform real-time analysis of the log data,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.cluster.ts

@@ -63,6 +63,7 @@ class TestStack extends cdk.Stack {
       parameterGroup: params,
       storageEncryptionKey: kmsKey,
       autoMinorVersionUpgrade: false,
+      deleteAutomatedBackups: false,
     });
 
     cluster.connections.allowDefaultPortFromAnyIpv4('Open to the world');
@@ -100,4 +101,3 @@ const stackWithFeatureFlag = new TestStack(appWithFeatureFlag, 'aws-cdk-rds-inte
 new IntegTest(appWithFeatureFlag, 'test-rds-cluster-with-feature-flag', {
   testCases: [stackWithFeatureFlag],
 });
-appWithFeatureFlag.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.proxy-endpoint.ts

@@ -0,0 +1,36 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as rds from 'aws-cdk-lib/aws-rds';
+
+const app = new App();
+const stack = new Stack(app, 'cdk-rds-proxy-endpoint');
+
+const vpc = new ec2.Vpc(stack, 'vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+const dbInstance = new rds.DatabaseInstance(stack, 'dbInstance', {
+  engine: rds.DatabaseInstanceEngine.postgres({
+    version: rds.PostgresEngineVersion.VER_17_5,
+  }),
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MEDIUM),
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+});
+
+const dbProxy = new rds.DatabaseProxy(stack, 'dbProxy', {
+  secrets: [dbInstance.secret!],
+  proxyTarget: rds.ProxyTarget.fromInstance(dbInstance),
+  vpc,
+});
+
+const securityGroup = ec2.SecurityGroup.fromSecurityGroupId(stack, 'SecurityGroup', vpc.vpcDefaultSecurityGroup);
+
+dbProxy.addEndpoint('dbProxyEndpoint', {
+  vpc,
+  targetRole: rds.ProxyEndpointTargetRole.READ_ONLY,
+  securityGroups: [securityGroup],
+});
+
+new integ.IntegTest(app, 'cdk-rds-proxy-endpoint-integ', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3/integ.bucket.notifications-scoped-permissions.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as sns from 'aws-cdk-lib/aws-sns';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
+import { Match, Template } from 'aws-cdk-lib/assertions';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-s3-notifications-scoped-permissions');
+
+// Create multiple buckets to test consolidated policy with scoped permissions
+const bucket1 = new s3.Bucket(stack, 'Bucket1', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+const bucket2 = new s3.Bucket(stack, 'Bucket2', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+const topic = new sns.Topic(stack, 'Topic');
+const queue = new sqs.Queue(stack, 'Queue', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+// Add notifications to multiple buckets with different event types - this should create scoped IAM permissions
+bucket1.addEventNotification(s3.EventType.OBJECT_CREATED_PUT, new s3n.SnsDestination(topic));
+bucket1.addEventNotification(s3.EventType.OBJECT_CREATED_POST, new s3n.SqsDestination(queue));
+bucket2.addEventNotification(s3.EventType.OBJECT_REMOVED_DELETE, new s3n.SnsDestination(topic));
+bucket2.addEventNotification(s3.EventType.OBJECT_REMOVED_DELETE_MARKER_CREATED, new s3n.SnsDestination(topic));
+
+// Create integration test with snapshot comparison enabled
+new integ.IntegTest(app, 'ScopedPermissionsTest', {
+  testCases: [stack],
+  diffAssets: true,
+});
+
+// Add assertions to verify IAM policies are scoped to specific bucket ARNs
+const template = Template.fromStack(stack);
+
+// Verify that IAM policies do not contain wildcard permissions
+template.hasResourceProperties('AWS::IAM::Policy', {
+  PolicyDocument: {
+    Statement: Match.arrayWith([
+      Match.objectLike({
+        Effect: 'Allow',
+        Action: 's3:PutBucketNotification',
+        Resource: Match.not('*'), // Ensure no wildcard permissions
+      }),
+    ]),
+  },
+});
+
+// Verify that the IAM policy contains specific bucket ARNs
+template.hasResourceProperties('AWS::IAM::Policy', {
+  PolicyDocument: {
+    Statement: Match.arrayWith([
+      Match.objectLike({
+        Effect: 'Allow',
+        Action: 's3:PutBucketNotification',
+        Resource: Match.arrayWith([
+          Match.objectLike({
+            'Fn::GetAtt': Match.arrayWith([Match.stringLikeRegexp('Bucket[12]'), 'Arn']),
+          }),
+        ]),
+      }),
+    ]),
+  },
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-assets/integ.assets.bundling.docker-opts.ts

@@ -9,7 +9,10 @@ const stack = new Stack(app, 'cdk-integ-assets-bundling-docker-opts');
 new assets.Asset(stack, 'BundledAsset', {
   path: path.join(__dirname, 'markdown-asset'), // /asset-input and working directory in the container
   bundling: {
-    image: DockerImage.fromBuild(path.join(__dirname, 'alpine-markdown')), // Build an image
+    // Build an image
+    image: DockerImage.fromBuild(path.join(__dirname, 'alpine-markdown'), {
+      platform: 'linux/amd64',
+    }),
     command: [
       'sh', '-c', `
         markdown index.md > /asset-output/index.html

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-parallel.ts

@@ -0,0 +1,82 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+const CSV_KEY = 'my-key.csv';
+
+class DistributedMapParallelStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const parallel = new sfn.Parallel(this, 'Parallel');
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    }).itemProcessor(new sfn.Pass(this, 'Pass'));
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(parallel.branch(distributedMap)),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapParallelStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  const expectSucceededExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectSucceededExecution);
+}
+
+const app = new cdk.App();
+const parallelStack = new DistributedMapParallelStack(app, 'DistributedMapParallelStack');
+
+const testCase = new integ.IntegTest(app, 'DistributedMapParallel', {
+  testCases: [parallelStack],
+});
+
+setupAssertions(parallelStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-redrive.ts

@@ -0,0 +1,130 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as aws_stepfunction_tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const CSV_KEY = 'my-key.csv';
+const SUCCESS_MARKER_KEY = 'pass-flag.txt';
+
+interface DistributedMapRedriveStackProps extends cdk.StackProps {
+  readonly mapRunLabel?: string;
+}
+
+class DistributedMapRedriveStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string, props?: DistributedMapRedriveStackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      label: props?.mapRunLabel,
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    });
+
+    // Existence of the success marker object determines if the distributed map succeeds or fails
+    const getSuccessMarker = new aws_stepfunction_tasks.CallAwsService(this, 'GetData', {
+      action: 'getObject',
+      iamResources: [this.bucket.arnForObjects('*')],
+      parameters: {
+        Bucket: this.bucket.bucketName,
+        Key: SUCCESS_MARKER_KEY,
+      },
+      service: 's3',
+    });
+
+    distributedMap.itemProcessor(getSuccessMarker);
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(distributedMap),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapRedriveStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  // describe the results of the execution
+  const expectFailedExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', {
+      executionArn: executionArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'FAILED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  // Upload the success marker, so that the next execution succeeds
+  const uploadSucceedMarker = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: SUCCESS_MARKER_KEY,
+    Body: '',
+  });
+
+  const redriveExecution = assertions.awsApiCall('StepFunctions', 'redriveExecution', {
+    executionArn: executionArn,
+  });
+
+  const expectRedrivenExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectFailedExecution)
+    .next(uploadSucceedMarker)
+    .next(redriveExecution)
+    .next(expectRedrivenExecution);
+}
+
+const app = new cdk.App();
+
+const unlabeledDistributedMapStack = new DistributedMapRedriveStack(app, 'UnlabeledDistributedMapRedrive');
+const labeledDistributedMapStack = new DistributedMapRedriveStack(app, 'LabeledDistributedMapRedrive', {
+  mapRunLabel: 'myLabel',
+});
+
+const testCase = new integ.IntegTest(app, 'DistributedMap', {
+  testCases: [unlabeledDistributedMapStack, labeledDistributedMapStack],
+});
+
+setupAssertions(labeledDistributedMapStack, testCase.assertions);
+setupAssertions(unlabeledDistributedMapStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.map-with-catch.ts

@@ -13,6 +13,7 @@ class DistributedMapStack extends cdk.Stack {
     super(scope, id, props);
 
     this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
       removalPolicy: cdk.RemovalPolicy.DESTROY,
     });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-nodejs22.ts

@@ -0,0 +1,27 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+class TestStack extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const task = new tasks.EvaluateExpression(this, 'Task', {
+      expression: '$.a + $.b',
+      runtime: lambda.Runtime.NODEJS_22_X,
+    });
+
+    new sfn.StateMachine(this, 'StateMachine', {
+      definition: task,
+    });
+  }
+}
+
+const app = new App();
+
+new integ.IntegTest(app, 'EvaluateExpressionNodejs22', {
+  testCases: [new TestStack(app, 'evaluate-expression-nodejs22')],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/README.md

@@ -165,6 +165,33 @@ const canary = new synthetics.Canary(this, 'MyCanary', {
 });
 ```
 
+### Browser Type Configuration
+
+You can configure which browsers your canary uses for testing by specifying the `browserConfigs` property. This allows you to test your application across different browsers to ensure compatibility.
+
+Available browser types:
+- `BrowserType.CHROME` - Google Chrome browser
+- `BrowserType.FIREFOX` - Mozilla Firefox browser
+
+You can specify up to 2 browser configurations. When multiple browsers are configured, the canary will run tests on each browser sequentially.
+
+```ts
+const canary = new synthetics.Canary(this, 'MyCanary', {
+  schedule: synthetics.Schedule.rate(Duration.minutes(5)),
+  test: synthetics.Test.custom({
+    code: synthetics.Code.fromAsset(path.join(__dirname, 'canary')),
+    handler: 'index.handler',
+  }),
+  runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_9_1,
+  browserConfigs: [
+    synthetics.BrowserType.CHROME,
+    synthetics.BrowserType.FIREFOX,
+  ],
+});
+```
+
+> **Note:** Firefox support is available for Node.js runtimes (Puppeteer and Playwright) but not for Python Selenium runtimes. When using Firefox, ensure your runtime version supports it.
+
 ### Deleting underlying resources on canary deletion
 
 When you delete a lambda, the following underlying resources are isolated in your AWS account:

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-browser-type.ts

@@ -0,0 +1,35 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public canary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.canary = new synthetics.Canary(this, 'BrowserTypeCanary', {
+      runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_11_0,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(2048),
+      timeout: Duration.minutes(4),
+      maxRetries: 2,
+      browserConfigs: [
+        synthetics.BrowserType.CHROME,
+        synthetics.BrowserType.FIREFOX,
+      ],
+    });
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryBrowserTypeStack');
+
+new IntegTest(app, 'SyntheticsCanaryBrowserType', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md

@@ -106,7 +106,7 @@ Flags come in three types:
 | [@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal](#aws-cdkaws-kmsapplyimportedaliaspermissionstoprincipal) | Enable grant methods on Aliases imported by name to use kms:ResourceAliases condition | 2.202.0 | fix |
 | [@aws-cdk/core:explicitStackTags](#aws-cdkcoreexplicitstacktags) | When enabled, stack tags need to be assigned explicitly on a Stack. | 2.205.0 | new default |
 | [@aws-cdk/aws-signer:signingProfileNamePassedToCfn](#aws-cdkaws-signersigningprofilenamepassedtocfn) | Pass signingProfileName to CfnSigningProfile | 2.212.0 | fix |
-| [@aws-cdk/aws-ecs-patterns:secGroupsDisablesImplicitOpenListener](#aws-cdkaws-ecs-patternssecgroupsdisablesimplicitopenlistener) | Disable implicit openListener when custom security groups are provided | V2NEXT | new default |
+| [@aws-cdk/aws-ecs-patterns:secGroupsDisablesImplicitOpenListener](#aws-cdkaws-ecs-patternssecgroupsdisablesimplicitopenlistener) | Disable implicit openListener when custom security groups are provided | 2.214.0 | new default |
 
 <!-- END table -->
 
@@ -2272,7 +2272,7 @@ override this behavior.
 | Since | Unset behaves like | Recommended value |
 | ----- | ----- | ----- |
 | (not in v1) |  |  |
-| V2NEXT | `false` | `true` |
+| 2.214.0 | `false` | `true` |
 
 **Compatibility with old behavior:** You can pass `openListener: true` explicitly to maintain the old behavior.
 

{konokenj_cdk_api_mcp_server-0.42.0.dist-info → konokenj_cdk_api_mcp_server-0.44.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.42.0
+Version: 0.44.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/konokenj.cdk-api-mcp-server.svg)](https://pypi.org/project/konokenj.cdk-api-mcp-server)
 
 <!-- DEP-VERSIONS-START -->
-[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.212.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
+[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.214.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---