truemark-cdk-lib 1.28.1 → 1.28.2

package/dist/aws-patterns-autobackup/lib/autobackup-construct.js

@@ -4,6 +4,7 @@ exports.AutoBackup = void 0;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_backup_1 = require("aws-cdk-lib/aws-backup");
 const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_cdk_1 = require("../../aws-cdk");
 class AutoBackup extends aws_cdk_1.ExtendedConstruct {
     daily(days) {
@@ -33,9 +34,12 @@ class AutoBackup extends aws_cdk_1.ExtendedConstruct {
         });
     }
     tagSelection(plan, tagValue) {
-        plan.addSelection('Selection', {
+        const selection = plan.addSelection('Selection', {
             resources: [aws_backup_1.BackupResource.fromTag('backup:policy', tagValue)],
         });
+        // The default backup policy does not cover S3, so a tagged bucket fails
+        // with a permission error until the S3-specific policy is attached.
+        selection.grantPrincipal.addManagedPolicy(aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName('AWSBackupServiceRolePolicyForS3Backup'));
     }
     constructor(scope, id, props = {}) {
         super(scope, id);
@@ -81,4 +85,4 @@ class AutoBackup extends aws_cdk_1.ExtendedConstruct {
     }
 }
 exports.AutoBackup = AutoBackup;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autobackup-construct.js","sourceRoot":"","sources":["../../../src/aws-patterns-autobackup/lib/autobackup-construct.ts"],"names":[],"mappings":";;;AAAA,6CAAqC;AACrC,uDAMgC;AAChC,uDAAgD;AAEhD,2CAAgD;AAgBhD,MAAa,UAAW,SAAQ,2BAAiB;IACvC,KAAK,CAAC,IAAY;QACxB,OAAO,IAAI,2BAAc,CAAC;YACxB,QAAQ,EAAE,OAAO;YACjB,kBAAkB,EAAE,qBAAQ,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAC,CAAC;YAC3D,WAAW,EAAE,sBAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;SACjC,CAAC,CAAC;IACL,CAAC;IAEO,MAAM,CAAC,IAAY;QACzB,OAAO,IAAI,2BAAc,CAAC;YACxB,QAAQ,EAAE,QAAQ;YAClB,kBAAkB,EAAE,qBAAQ,CAAC,IAAI,CAAC;gBAChC,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,KAAK;aACf,CAAC;YACF,WAAW,EAAE,sBAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;SACjC,CAAC,CAAC;IACL,CAAC;IAEO,OAAO,CAAC,IAAY;QAC1B,OAAO,IAAI,2BAAc,CAAC;YACxB,QAAQ,EAAE,SAAS;YACnB,kBAAkB,EAAE,qBAAQ,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAC,CAAC;YACrE,sBAAsB,EAAE,sBAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,WAAW,EAAE,sBAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;SACjC,CAAC,CAAC;IACL,CAAC;IAEO,YAAY,CAAC,IAAgB,EAAE,QAAgB;QACrD,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE;YAC7B,SAAS,EAAE,CAAC,2BAAc,CAAC,OAAO,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAyB,EAAE;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,WAAW,GAAG,IAAI,wBAAW,CAAC,IAAI,EAAE,SAAS,EAAE;YACnD,eAAe,EAAE,YAAY;SAC9B,CAAC,CAAC;QAEH,gDAAgD;QAChD,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;YAC1B,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,YAA8B,CAAC;YACjE,QAAQ,CAAC,iBAAiB,GAAG;gBAC3B,gBAAgB,EAAE,CAAC;gBACnB,gBAAgB,EAAE,IAAI;gBACtB,GAAG,CAAC,KAAK,CAAC,0BAA0B,KAAK,SAAS;oBAChD,CAAC,CAAC,EAAC,iBAAiB,EAAE,KAAK,CAAC,0BAA0B,EAAC;oBACvD,CAAC,CAAC,EAAE,CAAC;aACR,CAAC;QACJ,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,uBAAU,CAAC,IAAI,EAAE,aAAa,EAAE;YACtD,WAAW;YACX,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACjC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAE/C,MAAM,YAAY,GAAG,IAAI,uBAAU,CAAC,IAAI,EAAE,cAAc,EAAE;YACxD,WAAW;YACX,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;SAClC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;QAEjD,MAAM,cAAc,GAAG,IAAI,uBAAU,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAC5D,WAAW;YACX,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;SACnD,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;QAErD,MAAM,gCAAgC,GAAG,IAAI,uBAAU,CACrD,IAAI,EACJ,aAAa,EACb;YACE,WAAW;YACX,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;SACtE,CACF,CAAC;QACF,IAAI,CAAC,YAAY,CAAC,gCAAgC,EAAE,cAAc,CAAC,CAAC;QAEpE,MAAM,iCAAiC,GAAG,IAAI,uBAAU,CACtD,IAAI,EACJ,eAAe,EACf;YACE,WAAW;YACX,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SACvE,CACF,CAAC;QACF,IAAI,CAAC,YAAY,CAAC,iCAAiC,EAAE,iBAAiB,CAAC,CAAC;IAC1E,CAAC;CACF;AA7FD,gCA6FC","sourcesContent":["import {Duration} from 'aws-cdk-lib';\nimport {\n  BackupPlan,\n  BackupPlanRule,\n  BackupResource,\n  BackupVault,\n  type CfnBackupVault,\n} from 'aws-cdk-lib/aws-backup';\nimport {Schedule} from 'aws-cdk-lib/aws-events';\nimport type {Construct} from 'constructs';\nimport {ExtendedConstruct} from '../../aws-cdk';\n\nexport interface AutoBackupProps {\n  /**\n   * If true, applies AWS Backup Vault Lock to the AutoBackup vault.\n   * Note: Vault Lock applies to all recovery points in the vault.\n   */\n  enableImmutable?: boolean;\n\n  /**\n   * When provided (min 3), Vault Lock is Compliance mode.\n   * When omitted, Vault Lock is Governance mode.\n   */\n  vaultLockChangeableForDays?: number;\n}\n\nexport class AutoBackup extends ExtendedConstruct {\n  private daily(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Daily',\n      scheduleExpression: Schedule.cron({hour: '5', minute: '0'}),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private weekly(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Weekly',\n      scheduleExpression: Schedule.cron({\n        hour: '5',\n        minute: '0',\n        weekDay: 'SAT',\n      }),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private monthly(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Monthly',\n      scheduleExpression: Schedule.cron({day: '1', hour: '5', minute: '0'}),\n      moveToColdStorageAfter: Duration.days(30),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private tagSelection(plan: BackupPlan, tagValue: string) {\n    plan.addSelection('Selection', {\n      resources: [BackupResource.fromTag('backup:policy', tagValue)],\n    });\n  }\n\n  constructor(scope: Construct, id: string, props: AutoBackupProps = {}) {\n    super(scope, id);\n\n    const backupVault = new BackupVault(this, 'Default', {\n      backupVaultName: 'AutoBackup',\n    });\n\n    // Apply Vault Lock when enableImmutable is true\n    if (props.enableImmutable) {\n      const cfnVault = backupVault.node.defaultChild as CfnBackupVault;\n      cfnVault.lockConfiguration = {\n        minRetentionDays: 1,\n        maxRetentionDays: 2555,\n        ...(props.vaultLockChangeableForDays !== undefined\n          ? {changeableForDays: props.vaultLockChangeableForDays}\n          : {}),\n      };\n    }\n\n    const defaultWeek = new BackupPlan(this, 'DefaultWeek', {\n      backupVault,\n      backupPlanRules: [this.daily(7)],\n    });\n    this.tagSelection(defaultWeek, 'default-week');\n\n    const defaultMonth = new BackupPlan(this, 'DefaultMonth', {\n      backupVault,\n      backupPlanRules: [this.daily(35)],\n    });\n    this.tagSelection(defaultMonth, 'default-month');\n\n    const defaultQuarter = new BackupPlan(this, 'DefaultQuarter', {\n      backupVault,\n      backupPlanRules: [this.daily(35), this.weekly(90)],\n    });\n    this.tagSelection(defaultQuarter, 'default-quarter');\n\n    const defaultDaily35Weekly90Monthly365 = new BackupPlan(\n      this,\n      'DefaultYear',\n      {\n        backupVault,\n        backupPlanRules: [this.daily(35), this.weekly(90), this.monthly(365)],\n      },\n    );\n    this.tagSelection(defaultDaily35Weekly90Monthly365, 'default-year');\n\n    const defaultDaily35Weekly90Monthly2555 = new BackupPlan(\n      this,\n      'Default7Years',\n      {\n        backupVault,\n        backupPlanRules: [this.daily(35), this.weekly(90), this.monthly(2555)],\n      },\n    );\n    this.tagSelection(defaultDaily35Weekly90Monthly2555, 'default-7-years');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autobackup-construct.js","sourceRoot":"","sources":["../../../src/aws-patterns-autobackup/lib/autobackup-construct.ts"],"names":[],"mappings":"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","sourcesContent":["import {Duration} from 'aws-cdk-lib';\nimport {\n  BackupPlan,\n  BackupPlanRule,\n  BackupResource,\n  BackupVault,\n  type CfnBackupVault,\n} from 'aws-cdk-lib/aws-backup';\nimport {Schedule} from 'aws-cdk-lib/aws-events';\nimport {type IRole, ManagedPolicy} from 'aws-cdk-lib/aws-iam';\nimport type {Construct} from 'constructs';\nimport {ExtendedConstruct} from '../../aws-cdk';\n\nexport interface AutoBackupProps {\n  /**\n   * If true, applies AWS Backup Vault Lock to the AutoBackup vault.\n   * Note: Vault Lock applies to all recovery points in the vault.\n   */\n  enableImmutable?: boolean;\n\n  /**\n   * When provided (min 3), Vault Lock is Compliance mode.\n   * When omitted, Vault Lock is Governance mode.\n   */\n  vaultLockChangeableForDays?: number;\n}\n\nexport class AutoBackup extends ExtendedConstruct {\n  private daily(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Daily',\n      scheduleExpression: Schedule.cron({hour: '5', minute: '0'}),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private weekly(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Weekly',\n      scheduleExpression: Schedule.cron({\n        hour: '5',\n        minute: '0',\n        weekDay: 'SAT',\n      }),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private monthly(days: number): BackupPlanRule {\n    return new BackupPlanRule({\n      ruleName: 'Monthly',\n      scheduleExpression: Schedule.cron({day: '1', hour: '5', minute: '0'}),\n      moveToColdStorageAfter: Duration.days(30),\n      deleteAfter: Duration.days(days),\n    });\n  }\n\n  private tagSelection(plan: BackupPlan, tagValue: string) {\n    const selection = plan.addSelection('Selection', {\n      resources: [BackupResource.fromTag('backup:policy', tagValue)],\n    });\n    // The default backup policy does not cover S3, so a tagged bucket fails\n    // with a permission error until the S3-specific policy is attached.\n    (selection.grantPrincipal as IRole).addManagedPolicy(\n      ManagedPolicy.fromAwsManagedPolicyName(\n        'AWSBackupServiceRolePolicyForS3Backup',\n      ),\n    );\n  }\n\n  constructor(scope: Construct, id: string, props: AutoBackupProps = {}) {\n    super(scope, id);\n\n    const backupVault = new BackupVault(this, 'Default', {\n      backupVaultName: 'AutoBackup',\n    });\n\n    // Apply Vault Lock when enableImmutable is true\n    if (props.enableImmutable) {\n      const cfnVault = backupVault.node.defaultChild as CfnBackupVault;\n      cfnVault.lockConfiguration = {\n        minRetentionDays: 1,\n        maxRetentionDays: 2555,\n        ...(props.vaultLockChangeableForDays !== undefined\n          ? {changeableForDays: props.vaultLockChangeableForDays}\n          : {}),\n      };\n    }\n\n    const defaultWeek = new BackupPlan(this, 'DefaultWeek', {\n      backupVault,\n      backupPlanRules: [this.daily(7)],\n    });\n    this.tagSelection(defaultWeek, 'default-week');\n\n    const defaultMonth = new BackupPlan(this, 'DefaultMonth', {\n      backupVault,\n      backupPlanRules: [this.daily(35)],\n    });\n    this.tagSelection(defaultMonth, 'default-month');\n\n    const defaultQuarter = new BackupPlan(this, 'DefaultQuarter', {\n      backupVault,\n      backupPlanRules: [this.daily(35), this.weekly(90)],\n    });\n    this.tagSelection(defaultQuarter, 'default-quarter');\n\n    const defaultDaily35Weekly90Monthly365 = new BackupPlan(\n      this,\n      'DefaultYear',\n      {\n        backupVault,\n        backupPlanRules: [this.daily(35), this.weekly(90), this.monthly(365)],\n      },\n    );\n    this.tagSelection(defaultDaily35Weekly90Monthly365, 'default-year');\n\n    const defaultDaily35Weekly90Monthly2555 = new BackupPlan(\n      this,\n      'Default7Years',\n      {\n        backupVault,\n        backupPlanRules: [this.daily(35), this.weekly(90), this.monthly(2555)],\n      },\n    );\n    this.tagSelection(defaultDaily35Weekly90Monthly2555, 'default-7-years');\n  }\n}\n"]}

package/dist/aws-vpc/lib/index.d.ts

@@ -1,2 +1,3 @@
+export * from './nat-instance';
 export * from './network-parameters';
 export * from './standard-network';

package/dist/aws-vpc/lib/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nat-instance"), exports);
 __exportStar(require("./network-parameters"), exports);
 __exportStar(require("./standard-network"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzLXZwYy9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHVEQUFxQztBQUNyQyxxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25ldHdvcmstcGFyYW1ldGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3N0YW5kYXJkLW5ldHdvcmsnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzLXZwYy9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUErQjtBQUMvQix1REFBcUM7QUFDckMscURBQW1DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9uYXQtaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrLXBhcmFtZXRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFuZGFyZC1uZXR3b3JrJztcbiJdfQ==

package/dist/aws-vpc/lib/nat-instance.d.ts

@@ -0,0 +1,166 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import type { Construct } from 'constructs';
+import { ExtendedConstruct, type ExtendedConstructProps } from '../../aws-cdk/index';
+/**
+ * An additional file to write via cloud-init write_files.
+ */
+export interface NatInstanceWriteFile {
+    /** Absolute path on the instance where the file will be written. */
+    readonly path: string;
+    /** File content. */
+    readonly content: string;
+    /** Octal file permissions string, e.g. '0755'. */
+    readonly permissions?: string;
+}
+/**
+ * Properties for NatInstance.
+ */
+export interface NatInstanceProps extends ExtendedConstructProps {
+    /**
+     * VPC to place the NAT instance in.
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * The public subnet where the ENI and instance will live.
+     */
+    readonly publicSubnet: ec2.ISubnet;
+    /**
+     * CIDR blocks of private subnets. Used for the security group ingress rule
+     * so that private instances can route traffic through the NAT instance.
+     */
+    readonly privateSubnetCidrBlocks: string[];
+    /**
+     * Whether to run the ASG at desired capacity of 1. When false the ASG is
+     * set to desired/min=0, effectively pausing the NAT instance without
+     * destroying the ENI or other resources. Default is true.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * IDs of private route tables that should receive a 0.0.0.0/0 default
+     * route pointing to the NAT instance ENI. Typically one per AZ.
+     */
+    readonly privateRouteTableIds?: string[];
+    /**
+     * Custom AMI ID. When omitted the latest Amazon Linux 2023 standard AMI
+     * is used, filtered by the resolved architecture. The standard edition
+     * includes the SSM agent for remote management.
+     */
+    readonly imageId?: string;
+    /**
+     * CPU architecture used for the AMI lookup. Default is ARM_64, which
+     * corresponds to the default t4g.micro instance type.
+     *
+     * @default ec2.AmazonLinuxCpuType.ARM_64
+     */
+    readonly architecture?: ec2.AmazonLinuxCpuType;
+    /**
+     * EC2 instance types for the Auto Scaling Group mixed instances policy.
+     * Defaults based on architecture: t4g.micro for ARM64 (~$6/month on-demand),
+     * t3a.micro for X86_64 (~$7.60/month on-demand).
+     *
+     * @default [new ec2.InstanceType('t4g.micro')] for ARM64, [new ec2.InstanceType('t3a.micro')] for X86_64
+     */
+    readonly instanceTypes?: ec2.InstanceType[];
+    /**
+     * Use Spot instances instead of On-Demand. Spot can reduce cost to ~$1/month
+     * but the instance may be interrupted with a 2-minute warning. Default is false.
+     *
+     * @default false
+     */
+    readonly useSpotInstance?: boolean;
+    /**
+     * Name of an existing EC2 key pair to allow SSH access. When omitted,
+     * AWS Systems Manager Session Manager (enabled via the attached SSM policy)
+     * is the only console access method.
+     */
+    readonly keyName?: string;
+    /**
+     * Additional cloud-init write_files entries appended after the built-in
+     * NAT scripts. Useful for injecting custom configuration files.
+     */
+    readonly additionalWriteFiles?: NatInstanceWriteFile[];
+    /**
+     * Additional cloud-init runcmd entries appended after /opt/nat/runonce.sh.
+     * Each inner array represents one command invocation (argv style).
+     */
+    readonly additionalRunCmds?: string[][];
+    /**
+     * ARN of the IAM managed policy attached to the instance role for Systems
+     * Manager access. When omitted, uses AmazonSSMManagedInstanceCore resolved
+     * for the stack's partition (works in GovCloud and China).
+     *
+     * @default AmazonSSMManagedInstanceCore (partition-agnostic)
+     */
+    readonly ssmPolicyArn?: string;
+}
+/**
+ * A self-healing, cost-optimised NAT instance for private subnet egress.
+ *
+ * This is a CDK port of the truemark/nat-instance Terraform module. It
+ * provisions:
+ * - A dedicated secondary Elastic Network Interface (ENI) with source/dest
+ *   check disabled. Private subnets route to this ENI, which persists across
+ *   instance replacements. Actual NAT egress happens through the instance's
+ *   primary interface (which has an auto-assigned public IP by default).
+ * - An IAM role with AmazonSSMManagedInstanceCore and the EC2 permissions
+ *   needed for snat.sh to attach the secondary ENI at boot.
+ * - An EC2 Launch Template running Amazon Linux 2023 standard (ARM64 by
+ *   default) with a cloud-init user-data that installs iptables, attaches
+ *   the ENI, enables IP forwarding, and sets up NAT masquerading.
+ * - An Auto Scaling Group (desired=1) that auto-replaces the instance on
+ *   failure, keeping the ENI persistent across replacements.
+ * - Optional 0.0.0.0/0 routes in private route tables pointing to the ENI.
+ *
+ * **Usage with StandardNetwork:**
+ * ```ts
+ * const network = new StandardNetwork(this, 'Network', {
+ *   name: 'prod',
+ *   vpcCidr: '10.0.0.0/20',
+ *   natType: 'none',   // no managed NAT gateway
+ * });
+ *
+ * const nat = new NatInstance(this, 'Nat', {
+ *   vpc: network.vpc,
+ *   publicSubnet: network.vpc.selectSubnets({subnetGroupName: 'public'}).subnets[0],
+ *   privateSubnetCidrBlocks: ['10.0.0.0/24'],
+ *   privateRouteTableIds: network.vpc
+ *     .selectSubnets({subnetGroupName: 'private'})
+ *     .subnets.map(s => s.routeTable.routeTableId),
+ * });
+ *
+ * // The instance's primary interface gets an auto-assigned public IP.
+ * // For a stable outbound IP, allocate and associate an EIP with the
+ * // instance's primary interface using ASG lifecycle hooks or tags.
+ * // Example:
+ * // const eip = new ec2.CfnEIP(this, 'NatEip', {domain: 'vpc'});
+ * // Associate the EIP with new instances via lifecycle hook or tag matching.
+ * ```
+ *
+ * > **Note:** This construct is optimised for cost (ARM64 spot/on-demand
+ * > t4g.micro at ~$2–6/month) and is suitable for dev/staging environments.
+ * > For production use prefer AWS NAT Gateway or a larger instance type with
+ * > `useSpotInstance: false`.
+ */
+export declare class NatInstance extends ExtendedConstruct {
+    /**
+     * CloudFormation resource ID of the dedicated secondary ENI. Private subnet
+     * routes point to this ENI, which persists across instance replacements.
+     * Note: NAT egress occurs through the primary interface, not this ENI.
+     */
+    readonly eniId: string;
+    /**
+     * Primary private IPv4 address of the dedicated ENI.
+     */
+    readonly eniPrivateIp: string;
+    /**
+     * Security group ID of the NAT instance security group.
+     */
+    readonly sgId: string;
+    /**
+     * Name of the IAM role attached to the NAT instance.
+     */
+    readonly iamRoleName: string;
+    constructor(scope: Construct, id: string, props: NatInstanceProps);
+}

package/dist/aws-vpc/lib/nat-instance.js

@@ -0,0 +1,508 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatInstance = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const autoscaling = require("aws-cdk-lib/aws-autoscaling");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const iam = require("aws-cdk-lib/aws-iam");
+const index_1 = require("../../aws-cdk/index");
+const truemark_1 = require("../../truemark");
+// Verbatim content of the startup scripts, embedded at build time.
+// Shell `$var` and `$(cmd)` references are escaped as `\${var}` / `\$(cmd)`
+// to prevent TypeScript template-literal interpolation.
+const SNAT_SH = `#!/bin/sh
+set -e
+dnf install -y iptables-services awscli || yum install -y iptables-services awscli
+if test -f "/etc/nat.conf"; then
+    echo "Found nat configuration at /etc/nat.conf"
+    . /etc/nat.conf
+else
+    echo "No nat configuration at /etc/nat.conf"
+fi
+token="$(curl -sS -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 300' http://169.254.169.254/latest/api/token)"
+aws_region="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/placement/region)"
+instance_id="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/instance-id)"
+# Do not assume the primary interface is named eth0.
+# Use the interface that owns the default route.
+primary_interface="$(ip route | awk '/default/ {print $5; exit}')"
+if test -z "\${primary_interface}"; then
+    echo "Could not determine primary/default network interface"
+    ip route
+    exit 1
+fi
+primary_mac="$(cat /sys/class/net/\${primary_interface}/address)"
+echo "Primary/default interface is \${primary_interface} with MAC \${primary_mac}"
+if test -n "\${eni_id}"; then
+    echo "Found eni_id configuration, attaching \${eni_id}..."
+    primary_eni_id="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/network/interfaces/macs/\${primary_mac}/interface-id)"
+    echo "Disabling source/dest check on primary ENI \${primary_eni_id}..."
+    aws ec2 modify-network-interface-attribute \\
+        --region "\${aws_region}" \\
+        --network-interface-id "\${primary_eni_id}" \\
+        --source-dest-check '{"Value":false}'
+    echo "Disabling source/dest check on NAT ENI \${eni_id}..."
+    aws ec2 modify-network-interface-attribute \\
+        --region "\${aws_region}" \\
+        --network-interface-id "\${eni_id}" \\
+        --source-dest-check '{"Value":false}'
+    echo "Checking current attachment state for NAT ENI \${eni_id}..."
+    attached_instance_id="$(aws ec2 describe-network-interfaces \\
+        --region "\${aws_region}" \\
+        --network-interface-ids "\${eni_id}" \\
+        --query 'NetworkInterfaces[0].Attachment.InstanceId' \\
+        --output text 2>/dev/null || true)"
+    if test "\${attached_instance_id}" = "\${instance_id}"; then
+        echo "NAT ENI \${eni_id} is already attached to this instance."
+    elif test -n "\${attached_instance_id}" && test "\${attached_instance_id}" != "None"; then
+        echo "NAT ENI \${eni_id} is attached to another instance: \${attached_instance_id}"
+        echo "This may be the previous instance during replacement. Retrying for up to 60 seconds..."
+        for retry in $(seq 1 12); do
+            sleep 5
+            attached_instance_id="$(aws ec2 describe-network-interfaces \\
+                --region "\${aws_region}" \\
+                --network-interface-ids "\${eni_id}" \\
+                --query 'NetworkInterfaces[0].Attachment.InstanceId' \\
+                --output text 2>/dev/null || true)"
+            if test "\${attached_instance_id}" = "\${instance_id}"; then
+                echo "ENI is now attached to this instance."
+                break
+            elif test -z "\${attached_instance_id}" || test "\${attached_instance_id}" = "None"; then
+                echo "ENI is now available. Proceeding with attachment."
+                break
+            fi
+            echo "Retry \${retry}/12: ENI still attached to \${attached_instance_id}"
+        done
+        if test -n "\${attached_instance_id}" && test "\${attached_instance_id}" != "None" && test "\${attached_instance_id}" != "\${instance_id}"; then
+            echo "ERROR: ENI \${eni_id} is still attached to another instance after retries: \${attached_instance_id}"
+            # Systemd will retry this service. If all systemd retries are exhausted, terminate.
+            exit 1
+        fi
+    fi
+    if test "\${attached_instance_id}" != "\${instance_id}"; then
+        echo "Attaching NAT ENI \${eni_id} to instance \${instance_id}..."
+        # Use if statement to capture exit status before errexit triggers
+        if attach_output="$(aws ec2 attach-network-interface \\
+            --region "\${aws_region}" \\
+            --instance-id "\${instance_id}" \\
+            --device-index 1 \\
+            --network-interface-id "\${eni_id}" 2>&1)"; then
+            echo "\${attach_output}"
+            echo "ENI attached successfully."
+        else
+            attach_status=$?
+            echo "\${attach_output}"
+            echo "Failed to attach NAT ENI \${eni_id} with status \${attach_status}"
+            exit "\${attach_status}"
+        fi
+    fi
+    echo "Waiting for NAT ENI \${eni_id} to appear in metadata..."
+    nat_eni_mac=""
+    for attempt in $(seq 1 60); do
+        for mac in $(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/network/interfaces/macs/); do
+            interface_id="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/network/interfaces/macs/\${mac}interface-id)"
+            if test "\${interface_id}" = "\${eni_id}"; then
+                nat_eni_mac="$(echo "\${mac}" | sed 's#/$##')"
+                break
+            fi
+        done
+        if test -n "\${nat_eni_mac}"; then
+            break
+        fi
+        echo "Waiting for ENI metadata..."
+        sleep 2
+    done
+    if test -z "\${nat_eni_mac}"; then
+        echo "Could not find MAC address for NAT ENI \${eni_id}"
+        exit 1
+    fi
+    nat_eni_linux_device=""
+    for dev in $(ls /sys/class/net); do
+        dev_mac="$(cat /sys/class/net/\${dev}/address 2>/dev/null || true)"
+        if test "\${dev_mac}" = "\${nat_eni_mac}"; then
+            nat_eni_linux_device="\${dev}"
+            break
+        fi
+    done
+    if test -z "\${nat_eni_linux_device}"; then
+        echo "Could not map NAT ENI MAC \${nat_eni_mac} to Linux network device"
+        ip link show
+        exit 1
+    fi
+    echo "NAT ENI \${eni_id} is Linux device \${nat_eni_linux_device}"
+    # Private subnet routes target the NAT ENI for stable routing, but outbound
+    # SNAT leaves through the primary interface (which has the auto-assigned
+    # public IP or manually attached EIP). Secondary ENIs don't get auto-assigned
+    # public IPs, and setting up policy routing through eth1 is complex.
+    nat_interface="\${primary_interface}"
+    echo "Using outbound NAT interface \${nat_interface}"
+elif test -n "\${interface}"; then
+    echo "Found interface configuration, using \${interface}"
+    nat_interface="\${interface}"
+else
+    nat_interface="\${primary_interface}"
+    echo "No eni_id or interface configuration found, using default interface \${nat_interface}"
+fi
+echo "Enabling ip_forward..."
+sysctl -q -w net.ipv4.ip_forward=1
+echo "net.ipv4.ip_forward = 1" > /etc/sysctl.d/99-nat.conf
+echo "Disabling reverse path protection..."
+for i in $(find /proc/sys/net/ipv4/conf/ -name rp_filter); do
+  echo 0 > "\${i}";
+done
+cat > /etc/sysctl.d/98-disable-rp-filter.conf <<'EOF'
+net.ipv4.conf.all.rp_filter = 0
+net.ipv4.conf.default.rp_filter = 0
+EOF
+echo "Flushing NAT table..."
+iptables -t nat -F
+echo "Adding NAT rule..."
+iptables -t nat -A POSTROUTING -o "\${nat_interface}" -j MASQUERADE -m comment --comment "NAT routing rule installed"
+echo "Current NAT table:"
+iptables -t nat -L -n -v
+service iptables save || true
+echo "Done!"
+`;
+const SNAT_SERVICE = `[Unit]
+Description = Configure this machine to act as a NAT instance.
+Wants = network-online.target
+After = network-online.target
+# If NAT setup fails after all retries, terminate the instance so ASG replaces it
+OnFailure = snat-failure.service
+# Limit total retries to 10 attempts within a 10-minute window.
+# With RestartSec=30s, 10 attempts take ~5 minutes; this window ensures
+# the 10th failure triggers OnFailure rather than resetting the burst counter.
+StartLimitIntervalSec = 600
+StartLimitBurst = 10
+
+[Service]
+ExecStart = /opt/nat/snat.sh
+Type = oneshot
+# Retry on failure to handle transient ENI attachment issues during ASG replacement.
+# If ENI is still attached to previous instance, systemd will retry after 30s.
+Restart = on-failure
+RestartSec = 30s
+
+[Install]
+WantedBy = multi-user.target
+`;
+const SNAT_FAILURE_SERVICE = `[Unit]
+Description = Terminate NAT instance after unrecoverable setup failure
+DefaultDependencies = no
+
+[Service]
+Type = oneshot
+ExecStart = /opt/nat/terminate-on-failure.sh
+`;
+const TERMINATE_ON_FAILURE_SH = `#!/bin/sh
+# This script is invoked by snat-failure.service when NAT setup fails after all retries.
+# Terminating the instance triggers ASG to replace it, preventing blackholed routes.
+set -ex
+token="$(curl -sS -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 300' http://169.254.169.254/latest/api/token)"
+aws_region="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/placement/region)"
+instance_id="$(curl -sS -H "X-aws-ec2-metadata-token: \${token}" http://169.254.169.254/latest/meta-data/instance-id)"
+echo "FATAL: NAT setup failed after all retries. Terminating instance \${instance_id} to trigger ASG replacement..."
+aws ec2 terminate-instances --instance-ids "\${instance_id}" --region "\${aws_region}"
+`;
+const RUNONCE_SH = `#!/bin/bash -x
+
+# start SNAT
+systemctl enable snat
+systemctl start snat
+`;
+/**
+ * Indents script content for embedding in a YAML literal block scalar.
+ * Each line is prefixed with 4 spaces; blank lines are left truly empty
+ * to satisfy strict YAML parsers. The trailing newline produced by scripts
+ * ending with \n is consumed (the YAML `|` chomping handles it).
+ */
+function indentLiteralBlock(content) {
+    const lines = content.split('\n');
+    // Drop the last element when it is an empty string produced by a
+    // trailing \n — the `|` block indicator already implies one final newline.
+    if (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.map((line) => (line === '' ? '' : `    ${line}`)).join('\n');
+}
+/**
+ * Renders a single cloud-init write_files list entry as YAML, using a
+ * literal block scalar for the content field to avoid any escaping issues
+ * with shell special characters.
+ */
+function writeFileEntry(path, content, permissions) {
+    const permsLine = permissions !== undefined ? `\n  permissions: '${permissions}'` : '';
+    return `- path: ${path}${permsLine}\n  content: |\n${indentLiteralBlock(content)}\n`;
+}
+/**
+ * A self-healing, cost-optimised NAT instance for private subnet egress.
+ *
+ * This is a CDK port of the truemark/nat-instance Terraform module. It
+ * provisions:
+ * - A dedicated secondary Elastic Network Interface (ENI) with source/dest
+ *   check disabled. Private subnets route to this ENI, which persists across
+ *   instance replacements. Actual NAT egress happens through the instance's
+ *   primary interface (which has an auto-assigned public IP by default).
+ * - An IAM role with AmazonSSMManagedInstanceCore and the EC2 permissions
+ *   needed for snat.sh to attach the secondary ENI at boot.
+ * - An EC2 Launch Template running Amazon Linux 2023 standard (ARM64 by
+ *   default) with a cloud-init user-data that installs iptables, attaches
+ *   the ENI, enables IP forwarding, and sets up NAT masquerading.
+ * - An Auto Scaling Group (desired=1) that auto-replaces the instance on
+ *   failure, keeping the ENI persistent across replacements.
+ * - Optional 0.0.0.0/0 routes in private route tables pointing to the ENI.
+ *
+ * **Usage with StandardNetwork:**
+ * ```ts
+ * const network = new StandardNetwork(this, 'Network', {
+ *   name: 'prod',
+ *   vpcCidr: '10.0.0.0/20',
+ *   natType: 'none',   // no managed NAT gateway
+ * });
+ *
+ * const nat = new NatInstance(this, 'Nat', {
+ *   vpc: network.vpc,
+ *   publicSubnet: network.vpc.selectSubnets({subnetGroupName: 'public'}).subnets[0],
+ *   privateSubnetCidrBlocks: ['10.0.0.0/24'],
+ *   privateRouteTableIds: network.vpc
+ *     .selectSubnets({subnetGroupName: 'private'})
+ *     .subnets.map(s => s.routeTable.routeTableId),
+ * });
+ *
+ * // The instance's primary interface gets an auto-assigned public IP.
+ * // For a stable outbound IP, allocate and associate an EIP with the
+ * // instance's primary interface using ASG lifecycle hooks or tags.
+ * // Example:
+ * // const eip = new ec2.CfnEIP(this, 'NatEip', {domain: 'vpc'});
+ * // Associate the EIP with new instances via lifecycle hook or tag matching.
+ * ```
+ *
+ * > **Note:** This construct is optimised for cost (ARM64 spot/on-demand
+ * > t4g.micro at ~$2–6/month) and is suitable for dev/staging environments.
+ * > For production use prefer AWS NAT Gateway or a larger instance type with
+ * > `useSpotInstance: false`.
+ */
+class NatInstance extends index_1.ExtendedConstruct {
+    constructor(scope, id, props) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super(scope, id, {
+            standardTags: index_1.StandardTags.merge(props.standardTags, truemark_1.LibStandardTags),
+        });
+        const enabled = (_a = props.enabled) !== null && _a !== void 0 ? _a : true;
+        const architecture = (_b = props.architecture) !== null && _b !== void 0 ? _b : ec2.AmazonLinuxCpuType.ARM_64;
+        // Unique tag value for this NAT instance, used to scope IAM permissions.
+        // Includes stack name to ensure uniqueness across multiple stack deployments.
+        const natInstanceRoleTag = `nat-instance-${cdk.Stack.of(this).stackName}-${id}`;
+        // Derive default instance type from architecture to avoid AMI/instance mismatch
+        // Use micro (1GB RAM) instead of nano (512MB) to prevent OOM during package installation
+        const defaultInstanceType = architecture === ec2.AmazonLinuxCpuType.X86_64
+            ? new ec2.InstanceType('t3a.micro')
+            : new ec2.InstanceType('t4g.micro');
+        const instanceTypes = (_c = props.instanceTypes) !== null && _c !== void 0 ? _c : [defaultInstanceType];
+        if (instanceTypes.length === 0) {
+            throw new Error('instanceTypes must contain at least one instance type. Omit the property to use the architecture-appropriate default (t4g.micro for ARM64, t3a.micro for X86_64).');
+        }
+        const useSpotInstance = (_d = props.useSpotInstance) !== null && _d !== void 0 ? _d : false;
+        // ── Security Group ────────────────────────────────────────────────────────
+        const sg = new ec2.SecurityGroup(this, 'SecurityGroup', {
+            vpc: props.vpc,
+            description: `Security group for NAT instance ${id}`,
+            allowAllOutbound: true, // mirrors the egress all-traffic rule in Terraform
+        });
+        for (const cidr of props.privateSubnetCidrBlocks) {
+            sg.addIngressRule(ec2.Peer.ipv4(cidr), ec2.Port.allTraffic());
+        }
+        this.sgId = sg.securityGroupId;
+        // ── Elastic Network Interface ─────────────────────────────────────────────
+        // No L2 ENI construct exists — use L1 directly.
+        // source_dest_check=false is required for the instance to forward packets.
+        const eni = new ec2.CfnNetworkInterface(this, 'Eni', {
+            subnetId: props.publicSubnet.subnetId,
+            groupSet: [sg.securityGroupId],
+            sourceDestCheck: false,
+            description: `ENI for NAT instance ${id}`,
+        });
+        aws_cdk_lib_1.Tags.of(eni).add('Name', `nat-instance-${id}`);
+        this.eniId = eni.ref;
+        this.eniPrivateIp = eni.attrPrimaryPrivateIpAddress;
+        // ── Private Routes ────────────────────────────────────────────────────────
+        // CfnRoute is used because the L2 Route construct does not support
+        // targeting a raw ENI as the next hop.
+        const routeTableIds = (_e = props.privateRouteTableIds) !== null && _e !== void 0 ? _e : [];
+        for (let i = 0; i < routeTableIds.length; i++) {
+            new ec2.CfnRoute(this, `PrivateRoute${i}`, {
+                routeTableId: routeTableIds[i],
+                destinationCidrBlock: '0.0.0.0/0',
+                networkInterfaceId: eni.ref,
+            });
+        }
+        // ── IAM Role ──────────────────────────────────────────────────────────────
+        const role = new iam.Role(this, 'Role', {
+            assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+        });
+        // Add SSM managed policy (partition-agnostic when no override provided)
+        if (props.ssmPolicyArn) {
+            role.addManagedPolicy(iam.ManagedPolicy.fromManagedPolicyArn(this, 'SsmPolicy', props.ssmPolicyArn));
+        }
+        else {
+            role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'));
+        }
+        // snat.sh calls aws ec2 describe/attach/modify operations at instance boot.
+        // Describe actions use wildcard; Attach/Modify are constrained to the dedicated ENI.
+        role.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ['ec2:DescribeNetworkInterfaces', 'ec2:DescribeInstances'],
+            resources: ['*'],
+        }));
+        // AttachNetworkInterface on instances - restricted to instances with matching tag
+        // to prevent attaching arbitrary ENIs to arbitrary instances.
+        role.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ['ec2:AttachNetworkInterface'],
+            resources: [
+                `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:instance/*`,
+            ],
+            conditions: {
+                StringEquals: {
+                    'ec2:ResourceTag/nat-instance-role': natInstanceRoleTag,
+                },
+            },
+        }));
+        // AttachNetworkInterface only on the specific NAT ENI
+        role.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ['ec2:AttachNetworkInterface'],
+            resources: [
+                `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:network-interface/${eni.ref}`,
+            ],
+        }));
+        // ModifyNetworkInterfaceAttribute on network-interfaces within VPC (for primary ENI source/dest check)
+        role.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ['ec2:ModifyNetworkInterfaceAttribute'],
+            resources: [
+                `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:network-interface/*`,
+            ],
+            conditions: {
+                StringEquals: {
+                    'ec2:Vpc': `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:vpc/${props.vpc.vpcId}`,
+                },
+            },
+        }));
+        this.iamRoleName = role.roleName;
+        // ── Machine Image ─────────────────────────────────────────────────────────
+        const machineImage = props.imageId
+            ? new RawAmiMachineImage(props.imageId)
+            : ec2.MachineImage.latestAmazonLinux2023({
+                cpuType: architecture,
+                edition: ec2.AmazonLinuxEdition.STANDARD,
+            });
+        // ── User Data (cloud-init) ────────────────────────────────────────────────
+        // /etc/nat.conf tells snat.sh which ENI to attach as eth1 at boot.
+        // eni.ref is a CFN token resolved to the ENI resource ID at deploy time.
+        const natConfContent = `eni_id=${eni.ref}\n`;
+        const cloudConfig = '#cloud-config\n' +
+            'write_files:\n' +
+            writeFileEntry('/opt/nat/runonce.sh', RUNONCE_SH, '0755') +
+            writeFileEntry('/opt/nat/snat.sh', SNAT_SH, '0755') +
+            writeFileEntry('/opt/nat/terminate-on-failure.sh', TERMINATE_ON_FAILURE_SH, '0755') +
+            writeFileEntry('/etc/systemd/system/snat.service', SNAT_SERVICE) +
+            writeFileEntry('/etc/systemd/system/snat-failure.service', SNAT_FAILURE_SERVICE) +
+            // nat.conf: plain literal block — ENI ID is alphanumeric+hyphen, safe in YAML
+            `- path: /etc/nat.conf\n  permissions: '0644'\n  content: |\n    ${natConfContent}` +
+            ((_f = props.additionalWriteFiles) !== null && _f !== void 0 ? _f : [])
+                .map((f) => writeFileEntry(f.path, f.content, f.permissions))
+                .join('') +
+            'runcmd:\n' +
+            '- ["/opt/nat/runonce.sh"]\n' +
+            ((_g = props.additionalRunCmds) !== null && _g !== void 0 ? _g : [])
+                .map((cmd) => `- [${cmd.map((c) => JSON.stringify(c)).join(', ')}]\n`)
+                .join('');
+        const userData = ec2.UserData.custom(cloudConfig);
+        // ── Launch Template ───────────────────────────────────────────────────────
+        const lt = new ec2.LaunchTemplate(this, 'LaunchTemplate', {
+            machineImage,
+            role,
+            userData,
+            securityGroup: sg,
+            keyPair: props.keyName
+                ? ec2.KeyPair.fromKeyPairName(this, 'KeyPair', props.keyName)
+                : undefined,
+            requireImdsv2: true,
+            // instanceType is omitted — set via mixedInstancesPolicy overrides below
+        });
+        // ── Auto Scaling Group ────────────────────────────────────────────────────
+        const asg = new autoscaling.AutoScalingGroup(this, 'AutoScalingGroup', {
+            vpc: props.vpc,
+            // The pinned ENI controls actual AZ placement; vpcSubnets keeps CDK happy.
+            vpcSubnets: { subnets: [props.publicSubnet] },
+            minCapacity: enabled ? 1 : 0,
+            maxCapacity: 1,
+            desiredCapacity: enabled ? 1 : 0,
+            healthCheck: autoscaling.HealthCheck.ec2({
+                // Extended grace period to allow NAT setup to complete.
+                // Note: This only checks EC2 instance health, not NAT setup success directly.
+                // However, snat.service is configured to retry on failure and will terminate
+                // the instance if all retries are exhausted, triggering ASG replacement.
+                grace: cdk.Duration.minutes(5),
+            }),
+            mixedInstancesPolicy: {
+                launchTemplate: lt,
+                instancesDistribution: {
+                    onDemandBaseCapacity: useSpotInstance ? 0 : 1,
+                    onDemandPercentageAboveBaseCapacity: useSpotInstance ? 0 : 100,
+                },
+                launchTemplateOverrides: instanceTypes.map((it) => ({
+                    instanceType: it,
+                })),
+            },
+        });
+        // Tag the ASG instances with the unique identifier used in IAM conditions.
+        // This tag is propagated to instances and restricts IAM permissions to self-only operations.
+        aws_cdk_lib_1.Tags.of(asg).add('nat-instance-role', natInstanceRoleTag);
+        // Allow instance to terminate itself on unrecoverable NAT setup failure.
+        // Restricted to instances with the matching nat-instance-role tag,
+        // ensuring the instance can only terminate itself, not other instances in the VPC.
+        role.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ['ec2:TerminateInstances'],
+            resources: [
+                `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:instance/*`,
+            ],
+            conditions: {
+                StringEquals: {
+                    'ec2:ResourceTag/nat-instance-role': natInstanceRoleTag,
+                },
+            },
+        }));
+        // Use rolling update to avoid race condition with ENI attachment.
+        // autoScalingReplacingUpdate can create overlapping instances that both
+        // try to attach the singleton ENI, causing the boot script to fail.
+        const cfnAsg = asg.node.defaultChild;
+        cfnAsg.cfnOptions.updatePolicy = {
+            autoScalingRollingUpdate: {
+                maxBatchSize: 1,
+                minInstancesInService: 0,
+                pauseTime: 'PT5M',
+            },
+        };
+        aws_cdk_lib_1.Tags.of(asg).add('Name', `nat-instance-${id}`);
+    }
+}
+exports.NatInstance = NatInstance;
+/**
+ * Minimal IMachineImage implementation for a caller-supplied AMI ID.
+ *
+ * MachineImage.genericLinux() requires a concrete region key at synth time,
+ * which breaks environment-agnostic stacks. This implementation passes the
+ * AMI ID through directly and lets CloudFormation handle region resolution.
+ */
+class RawAmiMachineImage {
+    constructor(amiId) {
+        this.amiId = amiId;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getImage(_scope) {
+        return {
+            imageId: this.amiId,
+            osType: ec2.OperatingSystemType.LINUX,
+            userData: ec2.UserData.forLinux(),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nat-instance.js","sourceRoot":"","sources":["../../../src/aws-vpc/lib/nat-instance.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport {Tags} from 'aws-cdk-lib';\nimport * as autoscaling from 'aws-cdk-lib/aws-autoscaling';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport type {Construct} from 'constructs';\nimport {\n  ExtendedConstruct,\n  type ExtendedConstructProps,\n  StandardTags,\n} from '../../aws-cdk/index';\nimport {LibStandardTags} from '../../truemark';\n\n// Verbatim content of the startup scripts, embedded at build time.\n// Shell `$var` and `$(cmd)` references are escaped as `\\${var}` / `\\$(cmd)`\n// to prevent TypeScript template-literal interpolation.\n\nconst SNAT_SH = `#!/bin/sh\nset -e\ndnf install -y iptables-services awscli || yum install -y iptables-services awscli\nif test -f \"/etc/nat.conf\"; then\n    echo \"Found nat configuration at /etc/nat.conf\"\n    . /etc/nat.conf\nelse\n    echo \"No nat configuration at /etc/nat.conf\"\nfi\ntoken=\"$(curl -sS -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 300' http://169.254.169.254/latest/api/token)\"\naws_region=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/placement/region)\"\ninstance_id=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/instance-id)\"\n# Do not assume the primary interface is named eth0.\n# Use the interface that owns the default route.\nprimary_interface=\"$(ip route | awk '/default/ {print $5; exit}')\"\nif test -z \"\\${primary_interface}\"; then\n    echo \"Could not determine primary/default network interface\"\n    ip route\n    exit 1\nfi\nprimary_mac=\"$(cat /sys/class/net/\\${primary_interface}/address)\"\necho \"Primary/default interface is \\${primary_interface} with MAC \\${primary_mac}\"\nif test -n \"\\${eni_id}\"; then\n    echo \"Found eni_id configuration, attaching \\${eni_id}...\"\n    primary_eni_id=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/network/interfaces/macs/\\${primary_mac}/interface-id)\"\n    echo \"Disabling source/dest check on primary ENI \\${primary_eni_id}...\"\n    aws ec2 modify-network-interface-attribute \\\\\n        --region \"\\${aws_region}\" \\\\\n        --network-interface-id \"\\${primary_eni_id}\" \\\\\n        --source-dest-check '{\"Value\":false}'\n    echo \"Disabling source/dest check on NAT ENI \\${eni_id}...\"\n    aws ec2 modify-network-interface-attribute \\\\\n        --region \"\\${aws_region}\" \\\\\n        --network-interface-id \"\\${eni_id}\" \\\\\n        --source-dest-check '{\"Value\":false}'\n    echo \"Checking current attachment state for NAT ENI \\${eni_id}...\"\n    attached_instance_id=\"$(aws ec2 describe-network-interfaces \\\\\n        --region \"\\${aws_region}\" \\\\\n        --network-interface-ids \"\\${eni_id}\" \\\\\n        --query 'NetworkInterfaces[0].Attachment.InstanceId' \\\\\n        --output text 2>/dev/null || true)\"\n    if test \"\\${attached_instance_id}\" = \"\\${instance_id}\"; then\n        echo \"NAT ENI \\${eni_id} is already attached to this instance.\"\n    elif test -n \"\\${attached_instance_id}\" && test \"\\${attached_instance_id}\" != \"None\"; then\n        echo \"NAT ENI \\${eni_id} is attached to another instance: \\${attached_instance_id}\"\n        echo \"This may be the previous instance during replacement. Retrying for up to 60 seconds...\"\n        for retry in $(seq 1 12); do\n            sleep 5\n            attached_instance_id=\"$(aws ec2 describe-network-interfaces \\\\\n                --region \"\\${aws_region}\" \\\\\n                --network-interface-ids \"\\${eni_id}\" \\\\\n                --query 'NetworkInterfaces[0].Attachment.InstanceId' \\\\\n                --output text 2>/dev/null || true)\"\n            if test \"\\${attached_instance_id}\" = \"\\${instance_id}\"; then\n                echo \"ENI is now attached to this instance.\"\n                break\n            elif test -z \"\\${attached_instance_id}\" || test \"\\${attached_instance_id}\" = \"None\"; then\n                echo \"ENI is now available. Proceeding with attachment.\"\n                break\n            fi\n            echo \"Retry \\${retry}/12: ENI still attached to \\${attached_instance_id}\"\n        done\n        if test -n \"\\${attached_instance_id}\" && test \"\\${attached_instance_id}\" != \"None\" && test \"\\${attached_instance_id}\" != \"\\${instance_id}\"; then\n            echo \"ERROR: ENI \\${eni_id} is still attached to another instance after retries: \\${attached_instance_id}\"\n            # Systemd will retry this service. If all systemd retries are exhausted, terminate.\n            exit 1\n        fi\n    fi\n    if test \"\\${attached_instance_id}\" != \"\\${instance_id}\"; then\n        echo \"Attaching NAT ENI \\${eni_id} to instance \\${instance_id}...\"\n        # Use if statement to capture exit status before errexit triggers\n        if attach_output=\"$(aws ec2 attach-network-interface \\\\\n            --region \"\\${aws_region}\" \\\\\n            --instance-id \"\\${instance_id}\" \\\\\n            --device-index 1 \\\\\n            --network-interface-id \"\\${eni_id}\" 2>&1)\"; then\n            echo \"\\${attach_output}\"\n            echo \"ENI attached successfully.\"\n        else\n            attach_status=$?\n            echo \"\\${attach_output}\"\n            echo \"Failed to attach NAT ENI \\${eni_id} with status \\${attach_status}\"\n            exit \"\\${attach_status}\"\n        fi\n    fi\n    echo \"Waiting for NAT ENI \\${eni_id} to appear in metadata...\"\n    nat_eni_mac=\"\"\n    for attempt in $(seq 1 60); do\n        for mac in $(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/network/interfaces/macs/); do\n            interface_id=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/network/interfaces/macs/\\${mac}interface-id)\"\n            if test \"\\${interface_id}\" = \"\\${eni_id}\"; then\n                nat_eni_mac=\"$(echo \"\\${mac}\" | sed 's#/$##')\"\n                break\n            fi\n        done\n        if test -n \"\\${nat_eni_mac}\"; then\n            break\n        fi\n        echo \"Waiting for ENI metadata...\"\n        sleep 2\n    done\n    if test -z \"\\${nat_eni_mac}\"; then\n        echo \"Could not find MAC address for NAT ENI \\${eni_id}\"\n        exit 1\n    fi\n    nat_eni_linux_device=\"\"\n    for dev in $(ls /sys/class/net); do\n        dev_mac=\"$(cat /sys/class/net/\\${dev}/address 2>/dev/null || true)\"\n        if test \"\\${dev_mac}\" = \"\\${nat_eni_mac}\"; then\n            nat_eni_linux_device=\"\\${dev}\"\n            break\n        fi\n    done\n    if test -z \"\\${nat_eni_linux_device}\"; then\n        echo \"Could not map NAT ENI MAC \\${nat_eni_mac} to Linux network device\"\n        ip link show\n        exit 1\n    fi\n    echo \"NAT ENI \\${eni_id} is Linux device \\${nat_eni_linux_device}\"\n    # Private subnet routes target the NAT ENI for stable routing, but outbound\n    # SNAT leaves through the primary interface (which has the auto-assigned\n    # public IP or manually attached EIP). Secondary ENIs don't get auto-assigned\n    # public IPs, and setting up policy routing through eth1 is complex.\n    nat_interface=\"\\${primary_interface}\"\n    echo \"Using outbound NAT interface \\${nat_interface}\"\nelif test -n \"\\${interface}\"; then\n    echo \"Found interface configuration, using \\${interface}\"\n    nat_interface=\"\\${interface}\"\nelse\n    nat_interface=\"\\${primary_interface}\"\n    echo \"No eni_id or interface configuration found, using default interface \\${nat_interface}\"\nfi\necho \"Enabling ip_forward...\"\nsysctl -q -w net.ipv4.ip_forward=1\necho \"net.ipv4.ip_forward = 1\" > /etc/sysctl.d/99-nat.conf\necho \"Disabling reverse path protection...\"\nfor i in $(find /proc/sys/net/ipv4/conf/ -name rp_filter); do\n  echo 0 > \"\\${i}\";\ndone\ncat > /etc/sysctl.d/98-disable-rp-filter.conf <<'EOF'\nnet.ipv4.conf.all.rp_filter = 0\nnet.ipv4.conf.default.rp_filter = 0\nEOF\necho \"Flushing NAT table...\"\niptables -t nat -F\necho \"Adding NAT rule...\"\niptables -t nat -A POSTROUTING -o \"\\${nat_interface}\" -j MASQUERADE -m comment --comment \"NAT routing rule installed\"\necho \"Current NAT table:\"\niptables -t nat -L -n -v\nservice iptables save || true\necho \"Done!\"\n`;\n\nconst SNAT_SERVICE = `[Unit]\nDescription = Configure this machine to act as a NAT instance.\nWants = network-online.target\nAfter = network-online.target\n# If NAT setup fails after all retries, terminate the instance so ASG replaces it\nOnFailure = snat-failure.service\n# Limit total retries to 10 attempts within a 10-minute window.\n# With RestartSec=30s, 10 attempts take ~5 minutes; this window ensures\n# the 10th failure triggers OnFailure rather than resetting the burst counter.\nStartLimitIntervalSec = 600\nStartLimitBurst = 10\n\n[Service]\nExecStart = /opt/nat/snat.sh\nType = oneshot\n# Retry on failure to handle transient ENI attachment issues during ASG replacement.\n# If ENI is still attached to previous instance, systemd will retry after 30s.\nRestart = on-failure\nRestartSec = 30s\n\n[Install]\nWantedBy = multi-user.target\n`;\n\nconst SNAT_FAILURE_SERVICE = `[Unit]\nDescription = Terminate NAT instance after unrecoverable setup failure\nDefaultDependencies = no\n\n[Service]\nType = oneshot\nExecStart = /opt/nat/terminate-on-failure.sh\n`;\n\nconst TERMINATE_ON_FAILURE_SH = `#!/bin/sh\n# This script is invoked by snat-failure.service when NAT setup fails after all retries.\n# Terminating the instance triggers ASG to replace it, preventing blackholed routes.\nset -ex\ntoken=\"$(curl -sS -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 300' http://169.254.169.254/latest/api/token)\"\naws_region=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/placement/region)\"\ninstance_id=\"$(curl -sS -H \"X-aws-ec2-metadata-token: \\${token}\" http://169.254.169.254/latest/meta-data/instance-id)\"\necho \"FATAL: NAT setup failed after all retries. Terminating instance \\${instance_id} to trigger ASG replacement...\"\naws ec2 terminate-instances --instance-ids \"\\${instance_id}\" --region \"\\${aws_region}\"\n`;\n\nconst RUNONCE_SH = `#!/bin/bash -x\n\n# start SNAT\nsystemctl enable snat\nsystemctl start snat\n`;\n\n/**\n * An additional file to write via cloud-init write_files.\n */\nexport interface NatInstanceWriteFile {\n  /** Absolute path on the instance where the file will be written. */\n  readonly path: string;\n  /** File content. */\n  readonly content: string;\n  /** Octal file permissions string, e.g. '0755'. */\n  readonly permissions?: string;\n}\n\n/**\n * Properties for NatInstance.\n */\nexport interface NatInstanceProps extends ExtendedConstructProps {\n  /**\n   * VPC to place the NAT instance in.\n   */\n  readonly vpc: ec2.IVpc;\n\n  /**\n   * The public subnet where the ENI and instance will live.\n   */\n  readonly publicSubnet: ec2.ISubnet;\n\n  /**\n   * CIDR blocks of private subnets. Used for the security group ingress rule\n   * so that private instances can route traffic through the NAT instance.\n   */\n  readonly privateSubnetCidrBlocks: string[];\n\n  /**\n   * Whether to run the ASG at desired capacity of 1. When false the ASG is\n   * set to desired/min=0, effectively pausing the NAT instance without\n   * destroying the ENI or other resources. Default is true.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * IDs of private route tables that should receive a 0.0.0.0/0 default\n   * route pointing to the NAT instance ENI. Typically one per AZ.\n   */\n  readonly privateRouteTableIds?: string[];\n\n  /**\n   * Custom AMI ID. When omitted the latest Amazon Linux 2023 standard AMI\n   * is used, filtered by the resolved architecture. The standard edition\n   * includes the SSM agent for remote management.\n   */\n  readonly imageId?: string;\n\n  /**\n   * CPU architecture used for the AMI lookup. Default is ARM_64, which\n   * corresponds to the default t4g.micro instance type.\n   *\n   * @default ec2.AmazonLinuxCpuType.ARM_64\n   */\n  readonly architecture?: ec2.AmazonLinuxCpuType;\n\n  /**\n   * EC2 instance types for the Auto Scaling Group mixed instances policy.\n   * Defaults based on architecture: t4g.micro for ARM64 (~$6/month on-demand),\n   * t3a.micro for X86_64 (~$7.60/month on-demand).\n   *\n   * @default [new ec2.InstanceType('t4g.micro')] for ARM64, [new ec2.InstanceType('t3a.micro')] for X86_64\n   */\n  readonly instanceTypes?: ec2.InstanceType[];\n\n  /**\n   * Use Spot instances instead of On-Demand. Spot can reduce cost to ~$1/month\n   * but the instance may be interrupted with a 2-minute warning. Default is false.\n   *\n   * @default false\n   */\n  readonly useSpotInstance?: boolean;\n\n  /**\n   * Name of an existing EC2 key pair to allow SSH access. When omitted,\n   * AWS Systems Manager Session Manager (enabled via the attached SSM policy)\n   * is the only console access method.\n   */\n  readonly keyName?: string;\n\n  /**\n   * Additional cloud-init write_files entries appended after the built-in\n   * NAT scripts. Useful for injecting custom configuration files.\n   */\n  readonly additionalWriteFiles?: NatInstanceWriteFile[];\n\n  /**\n   * Additional cloud-init runcmd entries appended after /opt/nat/runonce.sh.\n   * Each inner array represents one command invocation (argv style).\n   */\n  readonly additionalRunCmds?: string[][];\n\n  /**\n   * ARN of the IAM managed policy attached to the instance role for Systems\n   * Manager access. When omitted, uses AmazonSSMManagedInstanceCore resolved\n   * for the stack's partition (works in GovCloud and China).\n   *\n   * @default AmazonSSMManagedInstanceCore (partition-agnostic)\n   */\n  readonly ssmPolicyArn?: string;\n}\n\n/**\n * Indents script content for embedding in a YAML literal block scalar.\n * Each line is prefixed with 4 spaces; blank lines are left truly empty\n * to satisfy strict YAML parsers. The trailing newline produced by scripts\n * ending with \\n is consumed (the YAML `|` chomping handles it).\n */\nfunction indentLiteralBlock(content: string): string {\n  const lines = content.split('\\n');\n  // Drop the last element when it is an empty string produced by a\n  // trailing \\n — the `|` block indicator already implies one final newline.\n  if (lines[lines.length - 1] === '') {\n    lines.pop();\n  }\n  return lines.map((line) => (line === '' ? '' : `    ${line}`)).join('\\n');\n}\n\n/**\n * Renders a single cloud-init write_files list entry as YAML, using a\n * literal block scalar for the content field to avoid any escaping issues\n * with shell special characters.\n */\nfunction writeFileEntry(\n  path: string,\n  content: string,\n  permissions?: string,\n): string {\n  const permsLine =\n    permissions !== undefined ? `\\n  permissions: '${permissions}'` : '';\n  return `- path: ${path}${permsLine}\\n  content: |\\n${indentLiteralBlock(content)}\\n`;\n}\n\n/**\n * A self-healing, cost-optimised NAT instance for private subnet egress.\n *\n * This is a CDK port of the truemark/nat-instance Terraform module. It\n * provisions:\n * - A dedicated secondary Elastic Network Interface (ENI) with source/dest\n *   check disabled. Private subnets route to this ENI, which persists across\n *   instance replacements. Actual NAT egress happens through the instance's\n *   primary interface (which has an auto-assigned public IP by default).\n * - An IAM role with AmazonSSMManagedInstanceCore and the EC2 permissions\n *   needed for snat.sh to attach the secondary ENI at boot.\n * - An EC2 Launch Template running Amazon Linux 2023 standard (ARM64 by\n *   default) with a cloud-init user-data that installs iptables, attaches\n *   the ENI, enables IP forwarding, and sets up NAT masquerading.\n * - An Auto Scaling Group (desired=1) that auto-replaces the instance on\n *   failure, keeping the ENI persistent across replacements.\n * - Optional 0.0.0.0/0 routes in private route tables pointing to the ENI.\n *\n * **Usage with StandardNetwork:**\n * ```ts\n * const network = new StandardNetwork(this, 'Network', {\n *   name: 'prod',\n *   vpcCidr: '10.0.0.0/20',\n *   natType: 'none',   // no managed NAT gateway\n * });\n *\n * const nat = new NatInstance(this, 'Nat', {\n *   vpc: network.vpc,\n *   publicSubnet: network.vpc.selectSubnets({subnetGroupName: 'public'}).subnets[0],\n *   privateSubnetCidrBlocks: ['10.0.0.0/24'],\n *   privateRouteTableIds: network.vpc\n *     .selectSubnets({subnetGroupName: 'private'})\n *     .subnets.map(s => s.routeTable.routeTableId),\n * });\n *\n * // The instance's primary interface gets an auto-assigned public IP.\n * // For a stable outbound IP, allocate and associate an EIP with the\n * // instance's primary interface using ASG lifecycle hooks or tags.\n * // Example:\n * // const eip = new ec2.CfnEIP(this, 'NatEip', {domain: 'vpc'});\n * // Associate the EIP with new instances via lifecycle hook or tag matching.\n * ```\n *\n * > **Note:** This construct is optimised for cost (ARM64 spot/on-demand\n * > t4g.micro at ~$2–6/month) and is suitable for dev/staging environments.\n * > For production use prefer AWS NAT Gateway or a larger instance type with\n * > `useSpotInstance: false`.\n */\nexport class NatInstance extends ExtendedConstruct {\n  /**\n   * CloudFormation resource ID of the dedicated secondary ENI. Private subnet\n   * routes point to this ENI, which persists across instance replacements.\n   * Note: NAT egress occurs through the primary interface, not this ENI.\n   */\n  readonly eniId: string;\n\n  /**\n   * Primary private IPv4 address of the dedicated ENI.\n   */\n  readonly eniPrivateIp: string;\n\n  /**\n   * Security group ID of the NAT instance security group.\n   */\n  readonly sgId: string;\n\n  /**\n   * Name of the IAM role attached to the NAT instance.\n   */\n  readonly iamRoleName: string;\n\n  constructor(scope: Construct, id: string, props: NatInstanceProps) {\n    super(scope, id, {\n      standardTags: StandardTags.merge(props.standardTags, LibStandardTags),\n    });\n\n    const enabled = props.enabled ?? true;\n    const architecture = props.architecture ?? ec2.AmazonLinuxCpuType.ARM_64;\n\n    // Unique tag value for this NAT instance, used to scope IAM permissions.\n    // Includes stack name to ensure uniqueness across multiple stack deployments.\n    const natInstanceRoleTag = `nat-instance-${cdk.Stack.of(this).stackName}-${id}`;\n\n    // Derive default instance type from architecture to avoid AMI/instance mismatch\n    // Use micro (1GB RAM) instead of nano (512MB) to prevent OOM during package installation\n    const defaultInstanceType =\n      architecture === ec2.AmazonLinuxCpuType.X86_64\n        ? new ec2.InstanceType('t3a.micro')\n        : new ec2.InstanceType('t4g.micro');\n\n    const instanceTypes = props.instanceTypes ?? [defaultInstanceType];\n    if (instanceTypes.length === 0) {\n      throw new Error(\n        'instanceTypes must contain at least one instance type. Omit the property to use the architecture-appropriate default (t4g.micro for ARM64, t3a.micro for X86_64).',\n      );\n    }\n    const useSpotInstance = props.useSpotInstance ?? false;\n\n    // ── Security Group ────────────────────────────────────────────────────────\n    const sg = new ec2.SecurityGroup(this, 'SecurityGroup', {\n      vpc: props.vpc,\n      description: `Security group for NAT instance ${id}`,\n      allowAllOutbound: true, // mirrors the egress all-traffic rule in Terraform\n    });\n    for (const cidr of props.privateSubnetCidrBlocks) {\n      sg.addIngressRule(ec2.Peer.ipv4(cidr), ec2.Port.allTraffic());\n    }\n    this.sgId = sg.securityGroupId;\n\n    // ── Elastic Network Interface ─────────────────────────────────────────────\n    // No L2 ENI construct exists — use L1 directly.\n    // source_dest_check=false is required for the instance to forward packets.\n    const eni = new ec2.CfnNetworkInterface(this, 'Eni', {\n      subnetId: props.publicSubnet.subnetId,\n      groupSet: [sg.securityGroupId],\n      sourceDestCheck: false,\n      description: `ENI for NAT instance ${id}`,\n    });\n    Tags.of(eni).add('Name', `nat-instance-${id}`);\n    this.eniId = eni.ref;\n    this.eniPrivateIp = eni.attrPrimaryPrivateIpAddress;\n\n    // ── Private Routes ────────────────────────────────────────────────────────\n    // CfnRoute is used because the L2 Route construct does not support\n    // targeting a raw ENI as the next hop.\n    const routeTableIds = props.privateRouteTableIds ?? [];\n    for (let i = 0; i < routeTableIds.length; i++) {\n      new ec2.CfnRoute(this, `PrivateRoute${i}`, {\n        routeTableId: routeTableIds[i],\n        destinationCidrBlock: '0.0.0.0/0',\n        networkInterfaceId: eni.ref,\n      });\n    }\n\n    // ── IAM Role ──────────────────────────────────────────────────────────────\n    const role = new iam.Role(this, 'Role', {\n      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n    });\n\n    // Add SSM managed policy (partition-agnostic when no override provided)\n    if (props.ssmPolicyArn) {\n      role.addManagedPolicy(\n        iam.ManagedPolicy.fromManagedPolicyArn(\n          this,\n          'SsmPolicy',\n          props.ssmPolicyArn,\n        ),\n      );\n    } else {\n      role.addManagedPolicy(\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonSSMManagedInstanceCore',\n        ),\n      );\n    }\n\n    // snat.sh calls aws ec2 describe/attach/modify operations at instance boot.\n    // Describe actions use wildcard; Attach/Modify are constrained to the dedicated ENI.\n    role.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:DescribeNetworkInterfaces', 'ec2:DescribeInstances'],\n        resources: ['*'],\n      }),\n    );\n    // AttachNetworkInterface on instances - restricted to instances with matching tag\n    // to prevent attaching arbitrary ENIs to arbitrary instances.\n    role.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:AttachNetworkInterface'],\n        resources: [\n          `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:instance/*`,\n        ],\n        conditions: {\n          StringEquals: {\n            'ec2:ResourceTag/nat-instance-role': natInstanceRoleTag,\n          },\n        },\n      }),\n    );\n    // AttachNetworkInterface only on the specific NAT ENI\n    role.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:AttachNetworkInterface'],\n        resources: [\n          `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:network-interface/${eni.ref}`,\n        ],\n      }),\n    );\n    // ModifyNetworkInterfaceAttribute on network-interfaces within VPC (for primary ENI source/dest check)\n    role.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:ModifyNetworkInterfaceAttribute'],\n        resources: [\n          `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:network-interface/*`,\n        ],\n        conditions: {\n          StringEquals: {\n            'ec2:Vpc': `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:vpc/${props.vpc.vpcId}`,\n          },\n        },\n      }),\n    );\n    this.iamRoleName = role.roleName;\n\n    // ── Machine Image ─────────────────────────────────────────────────────────\n    const machineImage: ec2.IMachineImage = props.imageId\n      ? new RawAmiMachineImage(props.imageId)\n      : ec2.MachineImage.latestAmazonLinux2023({\n          cpuType: architecture,\n          edition: ec2.AmazonLinuxEdition.STANDARD,\n        });\n\n    // ── User Data (cloud-init) ────────────────────────────────────────────────\n    // /etc/nat.conf tells snat.sh which ENI to attach as eth1 at boot.\n    // eni.ref is a CFN token resolved to the ENI resource ID at deploy time.\n    const natConfContent = `eni_id=${eni.ref}\\n`;\n\n    const cloudConfig =\n      '#cloud-config\\n' +\n      'write_files:\\n' +\n      writeFileEntry('/opt/nat/runonce.sh', RUNONCE_SH, '0755') +\n      writeFileEntry('/opt/nat/snat.sh', SNAT_SH, '0755') +\n      writeFileEntry(\n        '/opt/nat/terminate-on-failure.sh',\n        TERMINATE_ON_FAILURE_SH,\n        '0755',\n      ) +\n      writeFileEntry('/etc/systemd/system/snat.service', SNAT_SERVICE) +\n      writeFileEntry(\n        '/etc/systemd/system/snat-failure.service',\n        SNAT_FAILURE_SERVICE,\n      ) +\n      // nat.conf: plain literal block — ENI ID is alphanumeric+hyphen, safe in YAML\n      `- path: /etc/nat.conf\\n  permissions: '0644'\\n  content: |\\n    ${natConfContent}` +\n      (props.additionalWriteFiles ?? [])\n        .map((f) => writeFileEntry(f.path, f.content, f.permissions))\n        .join('') +\n      'runcmd:\\n' +\n      '- [\"/opt/nat/runonce.sh\"]\\n' +\n      (props.additionalRunCmds ?? [])\n        .map((cmd) => `- [${cmd.map((c) => JSON.stringify(c)).join(', ')}]\\n`)\n        .join('');\n\n    const userData = ec2.UserData.custom(cloudConfig);\n\n    // ── Launch Template ───────────────────────────────────────────────────────\n    const lt = new ec2.LaunchTemplate(this, 'LaunchTemplate', {\n      machineImage,\n      role,\n      userData,\n      securityGroup: sg,\n      keyPair: props.keyName\n        ? ec2.KeyPair.fromKeyPairName(this, 'KeyPair', props.keyName)\n        : undefined,\n      requireImdsv2: true,\n      // instanceType is omitted — set via mixedInstancesPolicy overrides below\n    });\n\n    // ── Auto Scaling Group ────────────────────────────────────────────────────\n    const asg = new autoscaling.AutoScalingGroup(this, 'AutoScalingGroup', {\n      vpc: props.vpc,\n      // The pinned ENI controls actual AZ placement; vpcSubnets keeps CDK happy.\n      vpcSubnets: {subnets: [props.publicSubnet]},\n      minCapacity: enabled ? 1 : 0,\n      maxCapacity: 1,\n      desiredCapacity: enabled ? 1 : 0,\n      healthCheck: autoscaling.HealthCheck.ec2({\n        // Extended grace period to allow NAT setup to complete.\n        // Note: This only checks EC2 instance health, not NAT setup success directly.\n        // However, snat.service is configured to retry on failure and will terminate\n        // the instance if all retries are exhausted, triggering ASG replacement.\n        grace: cdk.Duration.minutes(5),\n      }),\n      mixedInstancesPolicy: {\n        launchTemplate: lt,\n        instancesDistribution: {\n          onDemandBaseCapacity: useSpotInstance ? 0 : 1,\n          onDemandPercentageAboveBaseCapacity: useSpotInstance ? 0 : 100,\n        },\n        launchTemplateOverrides: instanceTypes.map((it) => ({\n          instanceType: it,\n        })),\n      },\n    });\n\n    // Tag the ASG instances with the unique identifier used in IAM conditions.\n    // This tag is propagated to instances and restricts IAM permissions to self-only operations.\n    Tags.of(asg).add('nat-instance-role', natInstanceRoleTag);\n\n    // Allow instance to terminate itself on unrecoverable NAT setup failure.\n    // Restricted to instances with the matching nat-instance-role tag,\n    // ensuring the instance can only terminate itself, not other instances in the VPC.\n    role.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:TerminateInstances'],\n        resources: [\n          `arn:${cdk.Stack.of(this).partition}:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:instance/*`,\n        ],\n        conditions: {\n          StringEquals: {\n            'ec2:ResourceTag/nat-instance-role': natInstanceRoleTag,\n          },\n        },\n      }),\n    );\n\n    // Use rolling update to avoid race condition with ENI attachment.\n    // autoScalingReplacingUpdate can create overlapping instances that both\n    // try to attach the singleton ENI, causing the boot script to fail.\n    const cfnAsg = asg.node.defaultChild as autoscaling.CfnAutoScalingGroup;\n    cfnAsg.cfnOptions.updatePolicy = {\n      autoScalingRollingUpdate: {\n        maxBatchSize: 1,\n        minInstancesInService: 0,\n        pauseTime: 'PT5M',\n      },\n    };\n\n    Tags.of(asg).add('Name', `nat-instance-${id}`);\n  }\n}\n\n/**\n * Minimal IMachineImage implementation for a caller-supplied AMI ID.\n *\n * MachineImage.genericLinux() requires a concrete region key at synth time,\n * which breaks environment-agnostic stacks. This implementation passes the\n * AMI ID through directly and lets CloudFormation handle region resolution.\n */\nclass RawAmiMachineImage implements ec2.IMachineImage {\n  constructor(private readonly amiId: string) {}\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  getImage(_scope: Construct): ec2.MachineImageConfig {\n    return {\n      imageId: this.amiId,\n      osType: ec2.OperatingSystemType.LINUX,\n      userData: ec2.UserData.forLinux(),\n    };\n  }\n}\n"]}

package/dist/aws-vpc/lib/standard-network.d.ts

@@ -2,7 +2,7 @@ import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import type { Construct } from 'constructs';
 import { ExtendedConstruct, type ExtendedConstructProps } from '../../aws-cdk';
 import { NetworkParameters } from './network-parameters';
-export type NatType = 'none' | 'single' | 'multi';
+export type NatType = 'none' | 'single' | 'multi' | 'natInstance';
 /**
  * Properties for StandardNetwork.
  */
@@ -18,11 +18,23 @@ export interface StandardNetworkProps extends ExtendedConstructProps {
      */
     readonly vpcCidr: string;
     /**
-     * Number of availability zones to deploy subnets into. Default is 2.
+     * Number of availability zones to deploy subnets into.
      *
-     * @default 2
+     * **Breaking Change**: The default was changed from 2 to 3 to align with AWS best
+     * practices for high availability. Existing consumers upgrading will see additional
+     * subnets and resources created unless they explicitly set `azCount: 2`.
+     *
+     * @default 3
      */
     readonly azCount?: number;
+    /**
+     * Whether to enable IPv6 for the VPC. When enabled, an Amazon-provided IPv6 CIDR
+     * block is associated with the VPC and subnets are configured with IPv6 addresses.
+     * Default is false.
+     *
+     * @default false
+     */
+    readonly enableIpv6?: boolean;
     /**
      * NAT gateway configuration. Default is 'none'.
      *
@@ -212,6 +224,10 @@ export interface StandardNetworkProps extends ExtendedConstructProps {
  * > addresses within the VPC. The subnet *sizes* match exactly; only the
  * > starting addresses within the VPC differ.
  *
+ * **IPv6 Support:** Set `enableIpv6: true` to configure the VPC in dual-stack
+ * mode with both IPv4 and IPv6. AWS automatically assigns an Amazon-provided
+ * /56 IPv6 CIDR block to the VPC, and each subnet receives a /64 IPv6 CIDR.
+ *
  * Gateway VPC endpoints for S3 and DynamoDB are created by default and attached
  * to private, intra, database, elasticache, and redshift route tables.
  *

package/dist/aws-vpc/lib/standard-network.js

@@ -5,8 +5,9 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const ec2 = require("aws-cdk-lib/aws-ec2");
 const aws_cdk_1 = require("../../aws-cdk");
 const truemark_1 = require("../../truemark");
+const nat_instance_1 = require("./nat-instance");
 const network_parameters_1 = require("./network-parameters");
-// TODO Need ipv6 support and we need to support ipv6 only
+// TODO Need to add support for ipv6 only mode (currently supports dual-stack)
 /**
  * Subnet sizing lookup table keyed by VPC prefix length.
  *
@@ -152,6 +153,10 @@ function applySubnetTags(subnets, tags) {
  * > addresses within the VPC. The subnet *sizes* match exactly; only the
  * > starting addresses within the VPC differ.
  *
+ * **IPv6 Support:** Set `enableIpv6: true` to configure the VPC in dual-stack
+ * mode with both IPv4 and IPv6. AWS automatically assigns an Amazon-provided
+ * /56 IPv6 CIDR block to the VPC, and each subnet receives a /64 IPv6 CIDR.
+ *
  * Gateway VPC endpoints for S3 and DynamoDB are created by default and attached
  * to private, intra, database, elasticache, and redshift route tables.
  *
@@ -165,11 +170,12 @@ class StandardNetwork extends aws_cdk_1.ExtendedConstruct {
             standardTags: aws_cdk_1.StandardTags.merge(props.standardTags, truemark_1.LibStandardTags),
         });
         // TODO You change the default here Daren
-        const azCount = (_a = props.azCount) !== null && _a !== void 0 ? _a : 2;
+        const azCount = (_a = props.azCount) !== null && _a !== void 0 ? _a : 3;
         const natType = (_b = props.natType) !== null && _b !== void 0 ? _b : 'none';
         const natGateways = natType === 'multi' ? azCount : natType === 'single' ? 1 : 0;
         // TODO Need to add support for regional NAT
         // TODO Need to add support for poor NAT
+        const useNatInstance = natType === 'natInstance';
         // TODO Need to add support for network firewall
         const createPublic = (_c = props.createPublicSubnets) !== null && _c !== void 0 ? _c : true;
         const createPrivate = (_d = props.createPrivateSubnets) !== null && _d !== void 0 ? _d : true;
@@ -205,6 +211,7 @@ class StandardNetwork extends aws_cdk_1.ExtendedConstruct {
                 name: 'public',
                 subnetType: ec2.SubnetType.PUBLIC,
                 cidrMask: masks.public,
+                mapPublicIpOnLaunch: true,
             });
         }
         if (createIntra) {
@@ -241,7 +248,39 @@ class StandardNetwork extends aws_cdk_1.ExtendedConstruct {
             natGateways,
             ipAddresses: ec2.IpAddresses.cidr(props.vpcCidr),
             subnetConfiguration,
+            ...(props.enableIpv6
+                ? {
+                    ipProtocol: ec2.IpProtocol.DUAL_STACK,
+                }
+                : {}),
         });
+        if (useNatInstance) {
+            if (!createPublic) {
+                throw new Error("natType 'natInstance' requires public subnets.");
+            }
+            // Get private subnets (PRIVATE_WITH_EGRESS type) for NAT routing.
+            // This includes: private, database, elasticache, and redshift subnet groups.
+            // This does NOT include: intra subnets (which are PRIVATE_ISOLATED and have no internet access).
+            const allPrivateSubnets = this.vpc.privateSubnets;
+            if (allPrivateSubnets.length === 0) {
+                throw new Error("natType 'natInstance' requires at least one private subnet.");
+            }
+            // Collect all private subnet CIDR blocks for security group rules
+            const privateCidrBlocks = allPrivateSubnets.map((s) => s.ipv4CidrBlock);
+            // Get private subnet route tables for NAT routing
+            const routeTableIds = allPrivateSubnets.map((s) => s.routeTable.routeTableId);
+            // The NAT instance's primary interface will receive an auto-assigned
+            // public IP from the public subnet, enabling immediate Internet egress.
+            // For a stable outbound IP, allocate an EIP and associate it with the
+            // instance's primary interface using ASG lifecycle hooks or tags.
+            new nat_instance_1.NatInstance(this, 'Nat', {
+                vpc: this.vpc,
+                publicSubnet: this.vpc.selectSubnets({ subnetGroupName: 'public' })
+                    .subnets[0],
+                privateSubnetCidrBlocks: privateCidrBlocks,
+                privateRouteTableIds: routeTableIds,
+            });
+        }
         // Apply per-subnet-group tags
         if (props.publicSubnetTags && createPublic) {
             applySubnetTags(this.vpc.selectSubnets({ subnetGroupName: 'public' }).subnets, props.publicSubnetTags);
@@ -381,4 +420,4 @@ class StandardNetwork extends aws_cdk_1.ExtendedConstruct {
     }
 }
 exports.StandardNetwork = StandardNetwork;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-network.js","sourceRoot":"","sources":["../../../src/aws-vpc/lib/standard-network.ts"],"names":[],"mappings":";;;AAAA,6CAAmD;AACnD,2CAA2C;AAE3C,2CAIuB;AACvB,6CAA+C;AAC/C,6DAAuD;AAIvD,0DAA0D;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,cAAc,GAClB;IACE,EAAE,EAAE,EAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAC;IAClC,EAAE,EAAE,EAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAC;IAClC,EAAE,EAAE,EAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAC;IAClC,EAAE,EAAE,EAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAC;IAClC,EAAE,EAAE,EAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAC;CACnC,CAAC;AAyNJ;;;;;;;GAOG;AACH,SAAS,kBAAkB,CACzB,OAAe,EACf,KAA2B;;IAE3B,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEhD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,qBAAqB,OAAO,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,4CAA4C;IAC5C,MAAM,IAAI,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;IAEvC,IAAI,WAAmB,CAAC;IACxB,IAAI,SAAiB,CAAC;IAEtB,IAAI,IAAI,EAAE,CAAC;QACT,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC;QAC3C,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;IACzC,CAAC;SAAM,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QAC9C,kEAAkE;QAClE,WAAW,GAAG,KAAK,CAAC,cAAc,CAAC;QACnC,SAAS,GAAG,KAAK,CAAC,cAAc,CAAC;IACnC,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,KAAK,CACb,eAAe,SAAS,yDAAyD;YAC/E,gDAAgD,CACnD,CAAC;IACJ,CAAC;IAED,4DAA4D;IAC5D,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,CAAC;IACzC,MAAM,eAAe,GAAG,WAAW,aAAX,WAAW,cAAX,WAAW,GAAI,WAAW,CAAC;IACnD,MAAM,aAAa,GAAG,WAAW,aAAX,WAAW,cAAX,WAAW,GAAI,SAAS,CAAC;IAE/C,OAAO;QACL,OAAO,EAAE,MAAA,KAAK,CAAC,qBAAqB,mCAAI,eAAe;QACvD,MAAM,EAAE,MAAA,KAAK,CAAC,oBAAoB,mCAAI,aAAa;QACnD,KAAK,EAAE,MAAA,KAAK,CAAC,mBAAmB,mCAAI,aAAa;QACjD,QAAQ,EAAE,MAAA,KAAK,CAAC,sBAAsB,mCAAI,aAAa;QACvD,WAAW,EAAE,MAAA,KAAK,CAAC,yBAAyB,mCAAI,aAAa;QAC7D,QAAQ,EAAE,MAAA,KAAK,CAAC,sBAAsB,mCAAI,aAAa;KACxD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAC3B,OAAe,EACf,OAAe,EACf,aAA6C;IAE7C,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEhD,+CAA+C;IAC/C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,EAAE,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC;QACrE,MAAM,IAAI,KAAK,CACb,oBAAoB,OAAO,kDAAkD,CAC9E,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,2CAA2C,OAAO,GAAG,CAAC,CAAC;IACzE,CAAC;IAED,0EAA0E;IAC1E,cAAc;IACd,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE,CAAC;QAC9B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,SAAS,IAAI,CAAC,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CACb,sBAAsB,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,IAAI,uBAAuB;gBAC/D,oCAAoC,SAAS,YAAY,CAC5D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IACrC,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE,CAAC;QAC9B,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;QACrC,WAAW,IAAI,QAAQ,CAAC;QACxB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,OAAO,OAAO,CAAC,CAAC,IAAI,MAAM,QAAQ,MAAM,CAAC,CAAC;IACtE,CAAC;IAED,IAAI,WAAW,GAAG,MAAM,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,YAAY,OAAO,KAAK,MAAM,uBAAuB;YACnD,aAAa,WAAW,eAAe,aAAa,CAAC,MAAM,mBAAmB;YAC9E,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;YACtC,yEAAyE,CAC5E,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CACtB,OAAsB,EACtB,IAA4B;IAE5B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,kBAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAa,eAAgB,SAAQ,2BAAiB;IAYpD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,YAAY,EAAE,sBAAY,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,EAAE,0BAAe,CAAC;SACtE,CAAC,CAAC;QAEH,yCAAyC;QACzC,MAAM,OAAO,GAAG,MAAA,KAAK,CAAC,OAAO,mCAAI,CAAC,CAAC;QACnC,MAAM,OAAO,GAAG,MAAA,KAAK,CAAC,OAAO,mCAAI,MAAM,CAAC;QAExC,MAAM,WAAW,GACf,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/D,4CAA4C;QAC5C,wCAAwC;QAExC,gDAAgD;QAEhD,MAAM,YAAY,GAAG,MAAA,KAAK,CAAC,mBAAmB,mCAAI,IAAI,CAAC;QACvD,MAAM,aAAa,GAAG,MAAA,KAAK,CAAC,oBAAoB,mCAAI,IAAI,CAAC;QACzD,MAAM,WAAW,GAAG,MAAA,KAAK,CAAC,kBAAkB,mCAAI,IAAI,CAAC;QACrD,MAAM,cAAc,GAAG,MAAA,KAAK,CAAC,qBAAqB,mCAAI,IAAI,CAAC;QAC3D,MAAM,iBAAiB,GAAG,MAAA,KAAK,CAAC,wBAAwB,mCAAI,IAAI,CAAC;QACjE,MAAM,cAAc,GAAG,MAAA,KAAK,CAAC,qBAAqB,mCAAI,KAAK,CAAC;QAE5D,MAAM,KAAK,GAAG,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEvD,MAAM,aAAa,GAAmC,EAAE,CAAC;QACzD,IAAI,YAAY;YAAE,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,CAAC,CAAC;QAC3E,IAAI,aAAa;YACf,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAC;QAC7D,IAAI,WAAW;YAAE,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAC;QACxE,IAAI,cAAc;YAChB,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAC;QAC/D,IAAI,iBAAiB;YACnB,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,WAAW,EAAE,IAAI,EAAE,aAAa,EAAC,CAAC,CAAC;QACrE,IAAI,cAAc;YAChB,aAAa,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAC;QAE/D,oBAAoB,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;QAE5D,MAAM,mBAAmB,GAA8B,EAAE,CAAC;QAE1D,IAAI,aAAa,EAAE,CAAC;YAClB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,SAAS;gBACf,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,mBAAmB;gBAC9C,QAAQ,EAAE,KAAK,CAAC,OAAO;aACxB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,YAAY,EAAE,CAAC;YACjB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,MAAM;gBACjC,QAAQ,EAAE,KAAK,CAAC,MAAM;aACvB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,WAAW,EAAE,CAAC;YAChB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,OAAO;gBACb,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,gBAAgB;gBAC3C,QAAQ,EAAE,KAAK,CAAC,KAAK;aACtB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,cAAc,EAAE,CAAC;YACnB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,UAAU;gBAChB,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,mBAAmB;gBAC9C,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,iBAAiB,EAAE,CAAC;YACtB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,aAAa;gBACnB,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,mBAAmB;gBAC9C,QAAQ,EAAE,KAAK,CAAC,WAAW;aAC5B,CAAC,CAAC;QACL,CAAC;QACD,IAAI,cAAc,EAAE,CAAC;YACnB,mBAAmB,CAAC,IAAI,CAAC;gBACvB,IAAI,EAAE,UAAU;gBAChB,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,mBAAmB;gBAC9C,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE;YAClC,OAAO,EAAE,KAAK,CAAC,IAAI;YACnB,MAAM,EAAE,OAAO;YACf,WAAW;YACX,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YAChD,mBAAmB;SACpB,CAAC,CAAC;QAEH,8BAA8B;QAC9B,IAAI,KAAK,CAAC,gBAAgB,IAAI,YAAY,EAAE,CAAC;YAC3C,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAC,CAAC,CAAC,OAAO,EAC3D,KAAK,CAAC,gBAAgB,CACvB,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,iBAAiB,IAAI,aAAa,EAAE,CAAC;YAC7C,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,SAAS,EAAC,CAAC,CAAC,OAAO,EAC5D,KAAK,CAAC,iBAAiB,CACxB,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,eAAe,IAAI,WAAW,EAAE,CAAC;YACzC,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC,CAAC,CAAC,OAAO,EAC1D,KAAK,CAAC,eAAe,CACtB,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,kBAAkB,IAAI,cAAc,EAAE,CAAC;YAC/C,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC,OAAO,EAC7D,KAAK,CAAC,kBAAkB,CACzB,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,qBAAqB,IAAI,iBAAiB,EAAE,CAAC;YACrD,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,aAAa,EAAC,CAAC,CAAC,OAAO,EAChE,KAAK,CAAC,qBAAqB,CAC5B,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,kBAAkB,IAAI,cAAc,EAAE,CAAC;YAC/C,eAAe,CACb,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC,OAAO,EAC7D,KAAK,CAAC,kBAAkB,CACzB,CAAC;QACJ,CAAC;QAED,qEAAqE;QACrE,MAAM,eAAe,GAA0B,EAAE,CAAC;QAClD,IAAI,aAAa;YAAE,eAAe,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,SAAS,EAAC,CAAC,CAAC;QACtE,IAAI,WAAW;YAAE,eAAe,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC,CAAC,CAAC;QAClE,IAAI,cAAc;YAAE,eAAe,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC;QACxE,IAAI,iBAAiB;YACnB,eAAe,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,aAAa,EAAC,CAAC,CAAC;QACzD,IAAI,cAAc;YAAE,eAAe,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC;QAExE,IAAI,CAAC,MAAA,KAAK,CAAC,gBAAgB,mCAAI,IAAI,CAAC,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnE,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,mBAAmB,EAAE;gBAC/C,OAAO,EAAE,GAAG,CAAC,4BAA4B,CAAC,EAAE;gBAC5C,OAAO,EAAE,eAAe;aACzB,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,MAAA,KAAK,CAAC,sBAAsB,mCAAI,IAAI,CAAC,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzE,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,yBAAyB,EAAE;gBACrD,OAAO,EAAE,GAAG,CAAC,4BAA4B,CAAC,QAAQ;gBAClD,OAAO,EAAE,eAAe;aACzB,CAAC,CAAC;QACL,CAAC;QAED,yBAAyB;QACzB,IAAI,MAAA,KAAK,CAAC,aAAa,mCAAI,IAAI,EAAE,CAAC;YAChC,MAAM,SAAS,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;YAE3C,IAAI,uBAAS,CAAC,IAAI,EAAE,OAAO,EAAE;gBAC3B,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK;gBACrB,UAAU,EAAE,GAAG,SAAS,QAAQ;aACjC,CAAC,CAAC;YAEH,IAAI,YAAY,EAAE,CAAC;gBACjB,IAAI,uBAAS,CAAC,IAAI,EAAE,iBAAiB,EAAE;oBACrC,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAC,CAAC;yBAC1C,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,kBAAkB;iBAC3C,CAAC,CAAC;YACL,CAAC;YACD,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAI,uBAAS,CAAC,IAAI,EAAE,kBAAkB,EAAE;oBACtC,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,SAAS,EAAC,CAAC;yBAC3C,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,mBAAmB;iBAC5C,CAAC,CAAC;YACL,CAAC;YACD,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,uBAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE;oBACpC,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC,CAAC;yBACzC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,iBAAiB;iBAC1C,CAAC,CAAC;YACL,CAAC;YACD,IAAI,cAAc,EAAE,CAAC;gBACnB,IAAI,uBAAS,CAAC,IAAI,EAAE,mBAAmB,EAAE;oBACvC,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC;yBAC5C,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,oBAAoB;iBAC7C,CAAC,CAAC;YACL,CAAC;YACD,IAAI,iBAAiB,EAAE,CAAC;gBACtB,IAAI,uBAAS,CAAC,IAAI,EAAE,sBAAsB,EAAE;oBAC1C,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,aAAa,EAAC,CAAC;yBAC/C,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,uBAAuB;iBAChD,CAAC,CAAC;YACL,CAAC;YACD,IAAI,cAAc,EAAE,CAAC;gBACnB,IAAI,uBAAS,CAAC,IAAI,EAAE,mBAAmB,EAAE;oBACvC,KAAK,EAAE,IAAI,CAAC,GAAG;yBACZ,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC;yBAC5C,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;oBACtB,UAAU,EAAE,GAAG,SAAS,oBAAoB;iBAC7C,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,4CAA4C;QAC5C,IAAI,MAAA,KAAK,CAAC,eAAe,mCAAI,IAAI,EAAE,CAAC;YAClC,IAAI,CAAC,iBAAiB,GAAG,IAAI,sCAAiB,CAC5C,IAAI,EACJ,mBAAmB,EACnB;gBACE,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,KAAK,CAAC,gBAAgB;gBAC9B,MAAM,EAAE,IAAI;gBACZ,SAAS,EAAE,KAAK;gBAChB,SAAS,EAAE,KAAK;gBAChB,mBAAmB,EAAE,KAAK;gBAC1B,oBAAoB,EAAE,KAAK;gBAC3B,kBAAkB,EAAE,KAAK;gBACzB,qBAAqB,EAAE,KAAK;gBAC5B,wBAAwB,EAAE,KAAK;gBAC/B,qBAAqB,EAAE,KAAK;gBAC5B,oBAAoB,EAAE,KAAK;gBAC3B,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK;gBACrB,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,iBAAiB;gBAC/B,eAAe,EAAE,YAAY;oBAC3B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAC,CAAC,CAAC,SAAS;oBAC/D,CAAC,CAAC,SAAS;gBACb,gBAAgB,EAAE,aAAa;oBAC7B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,SAAS,EAAC,CAAC,CAAC,SAAS;oBAChE,CAAC,CAAC,SAAS;gBACb,cAAc,EAAE,WAAW;oBACzB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC,CAAC,CAAC,SAAS;oBAC9D,CAAC,CAAC,SAAS;gBACb,iBAAiB,EAAE,cAAc;oBAC/B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC,SAAS;oBACjE,CAAC,CAAC,SAAS;gBACb,oBAAoB,EAAE,iBAAiB;oBACrC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,aAAa,EAAC,CAAC,CAAC,SAAS;oBACpE,CAAC,CAAC,SAAS;gBACb,iBAAiB,EAAE,cAAc;oBAC/B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAC,eAAe,EAAE,UAAU,EAAC,CAAC,CAAC,SAAS;oBACjE,CAAC,CAAC,SAAS;aACd,CACF,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA3QD,0CA2QC","sourcesContent":["import {CfnOutput, Stack, Tags} from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport type {Construct} from 'constructs';\nimport {\n  ExtendedConstruct,\n  type ExtendedConstructProps,\n  StandardTags,\n} from '../../aws-cdk';\nimport {LibStandardTags} from '../../truemark';\nimport {NetworkParameters} from './network-parameters';\n\nexport type NatType = 'none' | 'single' | 'multi'; // TODO Add  | 'regional' | 'poor';\n\n// TODO Need ipv6 support and we need to support ipv6 only\n\n/**\n * Subnet sizing lookup table keyed by VPC prefix length.\n *\n * Mirrors the `private_subnets` and `subnets` locals in truemark/terraform-aws-vpc:\n *\n *   VPC     private newbits  private mask   other newbits   other mask\n *   /16          3               /19              6              /22\n *   /17          3               /20              5              /22\n *   /18          3               /21              5              /23\n *   /19          3               /22              5              /24\n *   /20          4               /24              5              /25\n *\n * \"newbits\" is the number of bits to extend the VPC prefix.\n * cidrMask = vpcPrefix + newbits.\n */\nconst SUBNET_NEWBITS: Record<number, {privateBits: number; otherBits: number}> =\n  {\n    16: {privateBits: 3, otherBits: 6},\n    17: {privateBits: 3, otherBits: 5},\n    18: {privateBits: 3, otherBits: 5},\n    19: {privateBits: 3, otherBits: 5},\n    20: {privateBits: 4, otherBits: 5},\n  };\n\n/**\n * Properties for StandardNetwork.\n */\nexport interface StandardNetworkProps extends ExtendedConstructProps {\n  /**\n   * Name for the VPC. Used as the VPC name tag and the SSM parameter path\n   * segment (e.g. /network/{name}/vpc).\n   */\n  readonly name: string;\n\n  /**\n   * Full VPC CIDR block. e.g. \"10.0.0.0/20\".\n   * Supported VPC prefix lengths for auto-sizing: /16, /17, /18, /19, /20.\n   */\n  readonly vpcCidr: string;\n\n  // TODO Suggest both this and the terraform module default to 3\n  /**\n   * Number of availability zones to deploy subnets into. Default is 2.\n   *\n   * @default 2\n   */\n  readonly azCount?: number;\n\n  /**\n   * NAT gateway configuration. Default is 'none'.\n   *\n   * @default 'none'\n   */\n  readonly natType?: NatType;\n\n  /**\n   * Whether to create public subnets. Default is true.\n   *\n   * @default true\n   */\n  readonly createPublicSubnets?: boolean;\n\n  /**\n   * Whether to create private subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createPrivateSubnets?: boolean;\n\n  /**\n   * Whether to create intra subnets (PRIVATE_ISOLATED, no egress). Default is true.\n   *\n   * @default true\n   */\n  readonly createIntraSubnets?: boolean;\n\n  /**\n   * Whether to create database subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createDatabaseSubnets?: boolean;\n\n  /**\n   * Whether to create elasticache subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createElasticacheSubnets?: boolean;\n\n  /**\n   * Whether to create redshift subnets (PRIVATE_WITH_EGRESS). Default is false.\n   *\n   * @default false\n   */\n  readonly createRedshiftSubnets?: boolean;\n\n  /**\n   * Apply a uniform CIDR mask to ALL subnet groups, overriding the terraform-style\n   * auto-sizing. When set, all groups receive the same mask regardless of type.\n   * Per-group overrides below take precedence over this value.\n   */\n  readonly subnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for private subnets only.\n   *\n   * Equivalent to setting `private_newbits` in terraform-aws-vpc:\n   *   privateSubnetCidrMask = vpcPrefix + private_newbits\n   *\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly privateSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for public subnets only.\n   *\n   * Equivalent to setting `public_newbits` in terraform-aws-vpc:\n   *   publicSubnetCidrMask = vpcPrefix + public_newbits\n   *\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly publicSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for intra subnets only.\n   *\n   * Equivalent to setting `intra_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly intraSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for database subnets only.\n   *\n   * Equivalent to setting `database_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly databaseSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for elasticache subnets only.\n   *\n   * Equivalent to setting `elasticache_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly elasticacheSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for redshift subnets only.\n   *\n   * Equivalent to setting `redshift_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly redshiftSubnetCidrMask?: number;\n\n  /**\n   * Whether to create an S3 gateway VPC endpoint. The endpoint is attached to\n   * private, database, elasticache, redshift, and intra subnets (whichever are\n   * enabled). Default is true.\n   *\n   * @default true\n   */\n  readonly createS3Endpoint?: boolean;\n\n  /**\n   * Whether to create a DynamoDB gateway VPC endpoint. Attached to the same\n   * subnet groups as the S3 endpoint. Default is true.\n   *\n   * @default true\n   */\n  readonly createDynamoDbEndpoint?: boolean;\n\n  /**\n   * Whether to store VPC and subnet IDs in AWS SSM Parameter Store via the\n   * NetworkParameters construct. Default is true.\n   *\n   * @default true\n   */\n  readonly storeParameters?: boolean;\n\n  /**\n   * SSM parameter prefix used when storeParameters is true. Default is \"/network\".\n   *\n   * @default \"/network\"\n   */\n  readonly parametersPrefix?: string;\n\n  /**\n   * Whether to create CloudFormation stack outputs for VPC and subnet IDs.\n   * Default is true.\n   *\n   * @default true\n   */\n  readonly createOutputs?: boolean;\n\n  /**\n   * Additional tags to apply to public subnets.\n   */\n  readonly publicSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to private subnets.\n   */\n  readonly privateSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to intra subnets.\n   */\n  readonly intraSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to database subnets.\n   */\n  readonly databaseSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to elasticache subnets.\n   */\n  readonly elasticacheSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to redshift subnets.\n   */\n  readonly redshiftSubnetTags?: Record<string, string>;\n}\n\n/**\n * Resolved CIDR mask for each subnet group.\n */\ninterface ResolvedSubnetMasks {\n  private: number;\n  public: number;\n  intra: number;\n  database: number;\n  elasticache: number;\n  redshift: number;\n}\n\n/**\n * Determines the CIDR masks for each subnet group.\n *\n * Resolution order (highest wins):\n *   1. Per-group override (e.g. privateSubnetCidrMask)\n *   2. Uniform override  (subnetCidrMask)\n *   3. Terraform-table auto-sizing from the VPC prefix\n */\nfunction resolveSubnetMasks(\n  vpcCidr: string,\n  props: StandardNetworkProps,\n): ResolvedSubnetMasks {\n  const vpcPrefix = Number(vpcCidr.split('/')[1]);\n\n  if (!Number.isFinite(vpcPrefix)) {\n    throw new Error(`Invalid VPC CIDR: ${vpcCidr}`);\n  }\n\n  // --- Auto-sizing from terraform tables ---\n  const bits = SUBNET_NEWBITS[vpcPrefix];\n\n  let autoPrivate: number;\n  let autoOther: number;\n\n  if (bits) {\n    autoPrivate = vpcPrefix + bits.privateBits;\n    autoOther = vpcPrefix + bits.otherBits;\n  } else if (props.subnetCidrMask !== undefined) {\n    // Fall back to uniform when VPC prefix is outside the table range\n    autoPrivate = props.subnetCidrMask;\n    autoOther = props.subnetCidrMask;\n  } else {\n    throw new Error(\n      `VPC prefix /${vpcPrefix} is not in the auto-sizing table (supported: /16–/20). ` +\n        `Provide subnetCidrMask or per-group overrides.`,\n    );\n  }\n\n  // Uniform override replaces both private and other defaults\n  const uniformMask = props.subnetCidrMask;\n  const baseMaskPrivate = uniformMask ?? autoPrivate;\n  const baseMaskOther = uniformMask ?? autoOther;\n\n  return {\n    private: props.privateSubnetCidrMask ?? baseMaskPrivate,\n    public: props.publicSubnetCidrMask ?? baseMaskOther,\n    intra: props.intraSubnetCidrMask ?? baseMaskOther,\n    database: props.databaseSubnetCidrMask ?? baseMaskOther,\n    elasticache: props.elasticacheSubnetCidrMask ?? baseMaskOther,\n    redshift: props.redshiftSubnetCidrMask ?? baseMaskOther,\n  };\n}\n\n/**\n * Validates that the VPC CIDR has enough address space for all enabled subnet\n * groups. Each group consumes azCount × 2^(32-cidrMask) IPs.\n */\nfunction validateAddressSpace(\n  vpcCidr: string,\n  azCount: number,\n  enabledGroups: {mask: number; name: string}[],\n): void {\n  const vpcPrefix = Number(vpcCidr.split('/')[1]);\n\n  // AWS allows VPC netmasks between /16 and /28.\n  if (!Number.isInteger(vpcPrefix) || vpcPrefix < 16 || vpcPrefix > 28) {\n    throw new Error(\n      `Invalid VPC CIDR ${vpcCidr}: prefix must be an integer between /16 and /28.`,\n    );\n  }\n\n  if (!Number.isInteger(azCount) || azCount < 1) {\n    throw new Error(`azCount must be a positive integer, got ${azCount}.`);\n  }\n\n  // AWS subnet masks must be between /16 and /28, and never larger than the\n  // VPC itself.\n  for (const g of enabledGroups) {\n    if (!Number.isInteger(g.mask) || g.mask < vpcPrefix || g.mask > 28) {\n      throw new Error(\n        `Invalid CIDR mask /${g.mask} for ${g.name} subnets: must be an ` +\n          `integer between the VPC prefix (/${vpcPrefix}) and /28.`,\n      );\n    }\n  }\n\n  const vpcIps = 2 ** (32 - vpcPrefix);\n  let requiredIps = 0;\n  const detail: string[] = [];\n\n  for (const g of enabledGroups) {\n    const subnetIps = 2 ** (32 - g.mask);\n    const groupIps = azCount * subnetIps;\n    requiredIps += groupIps;\n    detail.push(`${g.name}: ${azCount} × /${g.mask} = ${groupIps} IPs`);\n  }\n\n  if (requiredIps > vpcIps) {\n    throw new Error(\n      `VPC CIDR ${vpcCidr} (${vpcIps} IPs) is too small.\\n` +\n        `Required: ${requiredIps} IPs across ${enabledGroups.length} subnet groups:\\n` +\n        detail.map((d) => `  ${d}`).join('\\n') +\n        '\\nIncrease the VPC size, reduce azCount, or disable some subnet groups.',\n    );\n  }\n}\n\nfunction applySubnetTags(\n  subnets: ec2.ISubnet[],\n  tags: Record<string, string>,\n): void {\n  for (const subnet of subnets) {\n    for (const [key, value] of Object.entries(tags)) {\n      Tags.of(subnet).add(key, value);\n    }\n  }\n}\n\n/**\n * Creates a standard multi-tier VPC following TrueMark conventions, with subnet\n * sizing that mirrors the truemark/terraform-aws-vpc Terraform module.\n *\n * **Subnet layout** (each group is replicated across all AZs):\n *\n * | Group       | Type                | Default sizing (auto, see table below) |\n * |-------------|---------------------|----------------------------------------|\n * | private     | PRIVATE_WITH_EGRESS | Larger — sized for workload traffic    |\n * | public      | PUBLIC              | Smaller                                |\n * | intra       | PRIVATE_ISOLATED    | Smaller — no egress                    |\n * | database    | PRIVATE_WITH_EGRESS | Smaller                                |\n * | elasticache | PRIVATE_WITH_EGRESS | Smaller                                |\n * | redshift    | PRIVATE_WITH_EGRESS | Smaller (disabled by default)          |\n *\n * **Auto-sizing table** (matches terraform-aws-vpc `private_subnets`/`subnets` locals):\n *\n * | VPC    | private | public/intra/database/elasticache/redshift |\n * |--------|---------|---------------------------------------------|\n * | /16    | /19     | /22                                         |\n * | /17    | /20     | /22                                         |\n * | /18    | /21     | /23                                         |\n * | /19    | /22     | /24                                         |\n * | /20    | /24     | /25                                         |\n *\n * Override sizing via `subnetCidrMask` (uniform) or per-group props like\n * `privateSubnetCidrMask`, `publicSubnetCidrMask`, etc. — equivalent to the\n * `private_newbits`, `public_newbits`, ... variables in Terraform.\n *\n * > **Note on CIDR placement:** CDK allocates subnet CIDRs sequentially from\n * > the start of the VPC CIDR block. This differs from Terraform's placement,\n * > which uses explicit `netnum` offsets to position subnet groups at specific\n * > addresses within the VPC. The subnet *sizes* match exactly; only the\n * > starting addresses within the VPC differ.\n *\n * Gateway VPC endpoints for S3 and DynamoDB are created by default and attached\n * to private, intra, database, elasticache, and redshift route tables.\n *\n * VPC and subnet IDs are stored in AWS SSM Parameter Store via NetworkParameters\n * and optionally exported as CloudFormation outputs.\n */\nexport class StandardNetwork extends ExtendedConstruct {\n  /**\n   * The VPC created by this construct.\n   */\n  readonly vpc: ec2.Vpc;\n\n  /**\n   * The NetworkParameters construct holding SSM paths and created parameters.\n   * Undefined when storeParameters is false.\n   */\n  readonly networkParameters?: NetworkParameters;\n\n  constructor(scope: Construct, id: string, props: StandardNetworkProps) {\n    super(scope, id, {\n      standardTags: StandardTags.merge(props.standardTags, LibStandardTags),\n    });\n\n    // TODO You change the default here Daren\n    const azCount = props.azCount ?? 2;\n    const natType = props.natType ?? 'none';\n\n    const natGateways =\n      natType === 'multi' ? azCount : natType === 'single' ? 1 : 0;\n\n    // TODO Need to add support for regional NAT\n    // TODO Need to add support for poor NAT\n\n    // TODO Need to add support for network firewall\n\n    const createPublic = props.createPublicSubnets ?? true;\n    const createPrivate = props.createPrivateSubnets ?? true;\n    const createIntra = props.createIntraSubnets ?? true;\n    const createDatabase = props.createDatabaseSubnets ?? true;\n    const createElasticache = props.createElasticacheSubnets ?? true;\n    const createRedshift = props.createRedshiftSubnets ?? false;\n\n    const masks = resolveSubnetMasks(props.vpcCidr, props);\n\n    const enabledGroups: {mask: number; name: string}[] = [];\n    if (createPublic) enabledGroups.push({mask: masks.public, name: 'public'});\n    if (createPrivate)\n      enabledGroups.push({mask: masks.private, name: 'private'});\n    if (createIntra) enabledGroups.push({mask: masks.intra, name: 'intra'});\n    if (createDatabase)\n      enabledGroups.push({mask: masks.database, name: 'database'});\n    if (createElasticache)\n      enabledGroups.push({mask: masks.elasticache, name: 'elasticache'});\n    if (createRedshift)\n      enabledGroups.push({mask: masks.redshift, name: 'redshift'});\n\n    validateAddressSpace(props.vpcCidr, azCount, enabledGroups);\n\n    const subnetConfiguration: ec2.SubnetConfiguration[] = [];\n\n    if (createPrivate) {\n      subnetConfiguration.push({\n        name: 'private',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.private,\n      });\n    }\n    if (createPublic) {\n      subnetConfiguration.push({\n        name: 'public',\n        subnetType: ec2.SubnetType.PUBLIC,\n        cidrMask: masks.public,\n      });\n    }\n    if (createIntra) {\n      subnetConfiguration.push({\n        name: 'intra',\n        subnetType: ec2.SubnetType.PRIVATE_ISOLATED,\n        cidrMask: masks.intra,\n      });\n    }\n    if (createDatabase) {\n      subnetConfiguration.push({\n        name: 'database',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.database,\n      });\n    }\n    if (createElasticache) {\n      subnetConfiguration.push({\n        name: 'elasticache',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.elasticache,\n      });\n    }\n    if (createRedshift) {\n      subnetConfiguration.push({\n        name: 'redshift',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.redshift,\n      });\n    }\n\n    this.vpc = new ec2.Vpc(this, 'Vpc', {\n      vpcName: props.name,\n      maxAzs: azCount,\n      natGateways,\n      ipAddresses: ec2.IpAddresses.cidr(props.vpcCidr),\n      subnetConfiguration,\n    });\n\n    // Apply per-subnet-group tags\n    if (props.publicSubnetTags && createPublic) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'public'}).subnets,\n        props.publicSubnetTags,\n      );\n    }\n    if (props.privateSubnetTags && createPrivate) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'private'}).subnets,\n        props.privateSubnetTags,\n      );\n    }\n    if (props.intraSubnetTags && createIntra) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'intra'}).subnets,\n        props.intraSubnetTags,\n      );\n    }\n    if (props.databaseSubnetTags && createDatabase) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'database'}).subnets,\n        props.databaseSubnetTags,\n      );\n    }\n    if (props.elasticacheSubnetTags && createElasticache) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'elasticache'}).subnets,\n        props.elasticacheSubnetTags,\n      );\n    }\n    if (props.redshiftSubnetTags && createRedshift) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'redshift'}).subnets,\n        props.redshiftSubnetTags,\n      );\n    }\n\n    // Build the list of subnet groups for gateway endpoint route tables.\n    const endpointSubnets: ec2.SubnetSelection[] = [];\n    if (createPrivate) endpointSubnets.push({subnetGroupName: 'private'});\n    if (createIntra) endpointSubnets.push({subnetGroupName: 'intra'});\n    if (createDatabase) endpointSubnets.push({subnetGroupName: 'database'});\n    if (createElasticache)\n      endpointSubnets.push({subnetGroupName: 'elasticache'});\n    if (createRedshift) endpointSubnets.push({subnetGroupName: 'redshift'});\n\n    if ((props.createS3Endpoint ?? true) && endpointSubnets.length > 0) {\n      this.vpc.addGatewayEndpoint('S3GatewayEndpoint', {\n        service: ec2.GatewayVpcEndpointAwsService.S3,\n        subnets: endpointSubnets,\n      });\n    }\n\n    if ((props.createDynamoDbEndpoint ?? true) && endpointSubnets.length > 0) {\n      this.vpc.addGatewayEndpoint('DynamoDbGatewayEndpoint', {\n        service: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n        subnets: endpointSubnets,\n      });\n    }\n\n    // CloudFormation outputs\n    if (props.createOutputs ?? true) {\n      const stackName = Stack.of(this).stackName;\n\n      new CfnOutput(this, 'VpcId', {\n        value: this.vpc.vpcId,\n        exportName: `${stackName}:VpcId`,\n      });\n\n      if (createPublic) {\n        new CfnOutput(this, 'PublicSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'public'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:PublicSubnetIds`,\n        });\n      }\n      if (createPrivate) {\n        new CfnOutput(this, 'PrivateSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'private'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:PrivateSubnetIds`,\n        });\n      }\n      if (createIntra) {\n        new CfnOutput(this, 'IntraSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'intra'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:IntraSubnetIds`,\n        });\n      }\n      if (createDatabase) {\n        new CfnOutput(this, 'DatabaseSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'database'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:DatabaseSubnetIds`,\n        });\n      }\n      if (createElasticache) {\n        new CfnOutput(this, 'ElasticacheSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'elasticache'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:ElasticacheSubnetIds`,\n        });\n      }\n      if (createRedshift) {\n        new CfnOutput(this, 'RedshiftSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'redshift'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:RedshiftSubnetIds`,\n        });\n      }\n    }\n\n    // SSM Parameter Store via NetworkParameters\n    if (props.storeParameters ?? true) {\n      this.networkParameters = new NetworkParameters(\n        this,\n        'NetworkParameters',\n        {\n          name: props.name,\n          prefix: props.parametersPrefix,\n          create: true,\n          lookupVpc: false,\n          lookupAzs: false,\n          lookupPublicSubnets: false,\n          lookupPrivateSubnets: false,\n          lookupIntraSubnets: false,\n          lookupDatabaseSubnets: false,\n          lookupElasticacheSubnets: false,\n          lookupRedshiftSubnets: false,\n          lookupOutpostSubnets: false,\n          vpcId: this.vpc.vpcId,\n          azs: this.vpc.availabilityZones,\n          publicSubnetIds: createPublic\n            ? this.vpc.selectSubnets({subnetGroupName: 'public'}).subnetIds\n            : undefined,\n          privateSubnetIds: createPrivate\n            ? this.vpc.selectSubnets({subnetGroupName: 'private'}).subnetIds\n            : undefined,\n          intraSubnetIds: createIntra\n            ? this.vpc.selectSubnets({subnetGroupName: 'intra'}).subnetIds\n            : undefined,\n          databaseSubnetIds: createDatabase\n            ? this.vpc.selectSubnets({subnetGroupName: 'database'}).subnetIds\n            : undefined,\n          elasticacheSubnetIds: createElasticache\n            ? this.vpc.selectSubnets({subnetGroupName: 'elasticache'}).subnetIds\n            : undefined,\n          redshiftSubnetIds: createRedshift\n            ? this.vpc.selectSubnets({subnetGroupName: 'redshift'}).subnetIds\n            : undefined,\n        },\n      );\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-network.js","sourceRoot":"","sources":["../../../src/aws-vpc/lib/standard-network.ts"],"names":[],"mappings":"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","sourcesContent":["import {CfnOutput, Stack, Tags} from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport type {Construct} from 'constructs';\nimport {\n  ExtendedConstruct,\n  type ExtendedConstructProps,\n  StandardTags,\n} from '../../aws-cdk';\nimport {LibStandardTags} from '../../truemark';\nimport {NatInstance} from './nat-instance';\nimport {NetworkParameters} from './network-parameters';\n\nexport type NatType = 'none' | 'single' | 'multi' | 'natInstance'; // TODO Add  | 'regional' | 'poor';\n\n// TODO Need to add support for ipv6 only mode (currently supports dual-stack)\n\n/**\n * Subnet sizing lookup table keyed by VPC prefix length.\n *\n * Mirrors the `private_subnets` and `subnets` locals in truemark/terraform-aws-vpc:\n *\n *   VPC     private newbits  private mask   other newbits   other mask\n *   /16          3               /19              6              /22\n *   /17          3               /20              5              /22\n *   /18          3               /21              5              /23\n *   /19          3               /22              5              /24\n *   /20          4               /24              5              /25\n *\n * \"newbits\" is the number of bits to extend the VPC prefix.\n * cidrMask = vpcPrefix + newbits.\n */\nconst SUBNET_NEWBITS: Record<number, {privateBits: number; otherBits: number}> =\n  {\n    16: {privateBits: 3, otherBits: 6},\n    17: {privateBits: 3, otherBits: 5},\n    18: {privateBits: 3, otherBits: 5},\n    19: {privateBits: 3, otherBits: 5},\n    20: {privateBits: 4, otherBits: 5},\n  };\n\n/**\n * Properties for StandardNetwork.\n */\nexport interface StandardNetworkProps extends ExtendedConstructProps {\n  /**\n   * Name for the VPC. Used as the VPC name tag and the SSM parameter path\n   * segment (e.g. /network/{name}/vpc).\n   */\n  readonly name: string;\n\n  /**\n   * Full VPC CIDR block. e.g. \"10.0.0.0/20\".\n   * Supported VPC prefix lengths for auto-sizing: /16, /17, /18, /19, /20.\n   */\n  readonly vpcCidr: string;\n\n  /**\n   * Number of availability zones to deploy subnets into.\n   *\n   * **Breaking Change**: The default was changed from 2 to 3 to align with AWS best\n   * practices for high availability. Existing consumers upgrading will see additional\n   * subnets and resources created unless they explicitly set `azCount: 2`.\n   *\n   * @default 3\n   */\n  readonly azCount?: number;\n\n  /**\n   * Whether to enable IPv6 for the VPC. When enabled, an Amazon-provided IPv6 CIDR\n   * block is associated with the VPC and subnets are configured with IPv6 addresses.\n   * Default is false.\n   *\n   * @default false\n   */\n  readonly enableIpv6?: boolean;\n\n  /**\n   * NAT gateway configuration. Default is 'none'.\n   *\n   * @default 'none'\n   */\n  readonly natType?: NatType;\n\n  /**\n   * Whether to create public subnets. Default is true.\n   *\n   * @default true\n   */\n  readonly createPublicSubnets?: boolean;\n\n  /**\n   * Whether to create private subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createPrivateSubnets?: boolean;\n\n  /**\n   * Whether to create intra subnets (PRIVATE_ISOLATED, no egress). Default is true.\n   *\n   * @default true\n   */\n  readonly createIntraSubnets?: boolean;\n\n  /**\n   * Whether to create database subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createDatabaseSubnets?: boolean;\n\n  /**\n   * Whether to create elasticache subnets (PRIVATE_WITH_EGRESS). Default is true.\n   *\n   * @default true\n   */\n  readonly createElasticacheSubnets?: boolean;\n\n  /**\n   * Whether to create redshift subnets (PRIVATE_WITH_EGRESS). Default is false.\n   *\n   * @default false\n   */\n  readonly createRedshiftSubnets?: boolean;\n\n  /**\n   * Apply a uniform CIDR mask to ALL subnet groups, overriding the terraform-style\n   * auto-sizing. When set, all groups receive the same mask regardless of type.\n   * Per-group overrides below take precedence over this value.\n   */\n  readonly subnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for private subnets only.\n   *\n   * Equivalent to setting `private_newbits` in terraform-aws-vpc:\n   *   privateSubnetCidrMask = vpcPrefix + private_newbits\n   *\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly privateSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for public subnets only.\n   *\n   * Equivalent to setting `public_newbits` in terraform-aws-vpc:\n   *   publicSubnetCidrMask = vpcPrefix + public_newbits\n   *\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly publicSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for intra subnets only.\n   *\n   * Equivalent to setting `intra_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly intraSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for database subnets only.\n   *\n   * Equivalent to setting `database_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly databaseSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for elasticache subnets only.\n   *\n   * Equivalent to setting `elasticache_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly elasticacheSubnetCidrMask?: number;\n\n  /**\n   * CIDR mask override for redshift subnets only.\n   *\n   * Equivalent to setting `redshift_newbits` in terraform-aws-vpc.\n   * Takes precedence over subnetCidrMask and auto-sizing.\n   */\n  readonly redshiftSubnetCidrMask?: number;\n\n  /**\n   * Whether to create an S3 gateway VPC endpoint. The endpoint is attached to\n   * private, database, elasticache, redshift, and intra subnets (whichever are\n   * enabled). Default is true.\n   *\n   * @default true\n   */\n  readonly createS3Endpoint?: boolean;\n\n  /**\n   * Whether to create a DynamoDB gateway VPC endpoint. Attached to the same\n   * subnet groups as the S3 endpoint. Default is true.\n   *\n   * @default true\n   */\n  readonly createDynamoDbEndpoint?: boolean;\n\n  /**\n   * Whether to store VPC and subnet IDs in AWS SSM Parameter Store via the\n   * NetworkParameters construct. Default is true.\n   *\n   * @default true\n   */\n  readonly storeParameters?: boolean;\n\n  /**\n   * SSM parameter prefix used when storeParameters is true. Default is \"/network\".\n   *\n   * @default \"/network\"\n   */\n  readonly parametersPrefix?: string;\n\n  /**\n   * Whether to create CloudFormation stack outputs for VPC and subnet IDs.\n   * Default is true.\n   *\n   * @default true\n   */\n  readonly createOutputs?: boolean;\n\n  /**\n   * Additional tags to apply to public subnets.\n   */\n  readonly publicSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to private subnets.\n   */\n  readonly privateSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to intra subnets.\n   */\n  readonly intraSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to database subnets.\n   */\n  readonly databaseSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to elasticache subnets.\n   */\n  readonly elasticacheSubnetTags?: Record<string, string>;\n\n  /**\n   * Additional tags to apply to redshift subnets.\n   */\n  readonly redshiftSubnetTags?: Record<string, string>;\n}\n\n/**\n * Resolved CIDR mask for each subnet group.\n */\ninterface ResolvedSubnetMasks {\n  private: number;\n  public: number;\n  intra: number;\n  database: number;\n  elasticache: number;\n  redshift: number;\n}\n\n/**\n * Determines the CIDR masks for each subnet group.\n *\n * Resolution order (highest wins):\n *   1. Per-group override (e.g. privateSubnetCidrMask)\n *   2. Uniform override  (subnetCidrMask)\n *   3. Terraform-table auto-sizing from the VPC prefix\n */\nfunction resolveSubnetMasks(\n  vpcCidr: string,\n  props: StandardNetworkProps,\n): ResolvedSubnetMasks {\n  const vpcPrefix = Number(vpcCidr.split('/')[1]);\n\n  if (!Number.isFinite(vpcPrefix)) {\n    throw new Error(`Invalid VPC CIDR: ${vpcCidr}`);\n  }\n\n  // --- Auto-sizing from terraform tables ---\n  const bits = SUBNET_NEWBITS[vpcPrefix];\n\n  let autoPrivate: number;\n  let autoOther: number;\n\n  if (bits) {\n    autoPrivate = vpcPrefix + bits.privateBits;\n    autoOther = vpcPrefix + bits.otherBits;\n  } else if (props.subnetCidrMask !== undefined) {\n    // Fall back to uniform when VPC prefix is outside the table range\n    autoPrivate = props.subnetCidrMask;\n    autoOther = props.subnetCidrMask;\n  } else {\n    throw new Error(\n      `VPC prefix /${vpcPrefix} is not in the auto-sizing table (supported: /16–/20). ` +\n        `Provide subnetCidrMask or per-group overrides.`,\n    );\n  }\n\n  // Uniform override replaces both private and other defaults\n  const uniformMask = props.subnetCidrMask;\n  const baseMaskPrivate = uniformMask ?? autoPrivate;\n  const baseMaskOther = uniformMask ?? autoOther;\n\n  return {\n    private: props.privateSubnetCidrMask ?? baseMaskPrivate,\n    public: props.publicSubnetCidrMask ?? baseMaskOther,\n    intra: props.intraSubnetCidrMask ?? baseMaskOther,\n    database: props.databaseSubnetCidrMask ?? baseMaskOther,\n    elasticache: props.elasticacheSubnetCidrMask ?? baseMaskOther,\n    redshift: props.redshiftSubnetCidrMask ?? baseMaskOther,\n  };\n}\n\n/**\n * Validates that the VPC CIDR has enough address space for all enabled subnet\n * groups. Each group consumes azCount × 2^(32-cidrMask) IPs.\n */\nfunction validateAddressSpace(\n  vpcCidr: string,\n  azCount: number,\n  enabledGroups: {mask: number; name: string}[],\n): void {\n  const vpcPrefix = Number(vpcCidr.split('/')[1]);\n\n  // AWS allows VPC netmasks between /16 and /28.\n  if (!Number.isInteger(vpcPrefix) || vpcPrefix < 16 || vpcPrefix > 28) {\n    throw new Error(\n      `Invalid VPC CIDR ${vpcCidr}: prefix must be an integer between /16 and /28.`,\n    );\n  }\n\n  if (!Number.isInteger(azCount) || azCount < 1) {\n    throw new Error(`azCount must be a positive integer, got ${azCount}.`);\n  }\n\n  // AWS subnet masks must be between /16 and /28, and never larger than the\n  // VPC itself.\n  for (const g of enabledGroups) {\n    if (!Number.isInteger(g.mask) || g.mask < vpcPrefix || g.mask > 28) {\n      throw new Error(\n        `Invalid CIDR mask /${g.mask} for ${g.name} subnets: must be an ` +\n          `integer between the VPC prefix (/${vpcPrefix}) and /28.`,\n      );\n    }\n  }\n\n  const vpcIps = 2 ** (32 - vpcPrefix);\n  let requiredIps = 0;\n  const detail: string[] = [];\n\n  for (const g of enabledGroups) {\n    const subnetIps = 2 ** (32 - g.mask);\n    const groupIps = azCount * subnetIps;\n    requiredIps += groupIps;\n    detail.push(`${g.name}: ${azCount} × /${g.mask} = ${groupIps} IPs`);\n  }\n\n  if (requiredIps > vpcIps) {\n    throw new Error(\n      `VPC CIDR ${vpcCidr} (${vpcIps} IPs) is too small.\\n` +\n        `Required: ${requiredIps} IPs across ${enabledGroups.length} subnet groups:\\n` +\n        detail.map((d) => `  ${d}`).join('\\n') +\n        '\\nIncrease the VPC size, reduce azCount, or disable some subnet groups.',\n    );\n  }\n}\n\nfunction applySubnetTags(\n  subnets: ec2.ISubnet[],\n  tags: Record<string, string>,\n): void {\n  for (const subnet of subnets) {\n    for (const [key, value] of Object.entries(tags)) {\n      Tags.of(subnet).add(key, value);\n    }\n  }\n}\n\n/**\n * Creates a standard multi-tier VPC following TrueMark conventions, with subnet\n * sizing that mirrors the truemark/terraform-aws-vpc Terraform module.\n *\n * **Subnet layout** (each group is replicated across all AZs):\n *\n * | Group       | Type                | Default sizing (auto, see table below) |\n * |-------------|---------------------|----------------------------------------|\n * | private     | PRIVATE_WITH_EGRESS | Larger — sized for workload traffic    |\n * | public      | PUBLIC              | Smaller                                |\n * | intra       | PRIVATE_ISOLATED    | Smaller — no egress                    |\n * | database    | PRIVATE_WITH_EGRESS | Smaller                                |\n * | elasticache | PRIVATE_WITH_EGRESS | Smaller                                |\n * | redshift    | PRIVATE_WITH_EGRESS | Smaller (disabled by default)          |\n *\n * **Auto-sizing table** (matches terraform-aws-vpc `private_subnets`/`subnets` locals):\n *\n * | VPC    | private | public/intra/database/elasticache/redshift |\n * |--------|---------|---------------------------------------------|\n * | /16    | /19     | /22                                         |\n * | /17    | /20     | /22                                         |\n * | /18    | /21     | /23                                         |\n * | /19    | /22     | /24                                         |\n * | /20    | /24     | /25                                         |\n *\n * Override sizing via `subnetCidrMask` (uniform) or per-group props like\n * `privateSubnetCidrMask`, `publicSubnetCidrMask`, etc. — equivalent to the\n * `private_newbits`, `public_newbits`, ... variables in Terraform.\n *\n * > **Note on CIDR placement:** CDK allocates subnet CIDRs sequentially from\n * > the start of the VPC CIDR block. This differs from Terraform's placement,\n * > which uses explicit `netnum` offsets to position subnet groups at specific\n * > addresses within the VPC. The subnet *sizes* match exactly; only the\n * > starting addresses within the VPC differ.\n *\n * **IPv6 Support:** Set `enableIpv6: true` to configure the VPC in dual-stack\n * mode with both IPv4 and IPv6. AWS automatically assigns an Amazon-provided\n * /56 IPv6 CIDR block to the VPC, and each subnet receives a /64 IPv6 CIDR.\n *\n * Gateway VPC endpoints for S3 and DynamoDB are created by default and attached\n * to private, intra, database, elasticache, and redshift route tables.\n *\n * VPC and subnet IDs are stored in AWS SSM Parameter Store via NetworkParameters\n * and optionally exported as CloudFormation outputs.\n */\nexport class StandardNetwork extends ExtendedConstruct {\n  /**\n   * The VPC created by this construct.\n   */\n  readonly vpc: ec2.Vpc;\n\n  /**\n   * The NetworkParameters construct holding SSM paths and created parameters.\n   * Undefined when storeParameters is false.\n   */\n  readonly networkParameters?: NetworkParameters;\n\n  constructor(scope: Construct, id: string, props: StandardNetworkProps) {\n    super(scope, id, {\n      standardTags: StandardTags.merge(props.standardTags, LibStandardTags),\n    });\n\n    // TODO You change the default here Daren\n    const azCount = props.azCount ?? 3;\n    const natType = props.natType ?? 'none';\n\n    const natGateways =\n      natType === 'multi' ? azCount : natType === 'single' ? 1 : 0;\n\n    // TODO Need to add support for regional NAT\n    // TODO Need to add support for poor NAT\n    const useNatInstance = natType === 'natInstance';\n\n    // TODO Need to add support for network firewall\n\n    const createPublic = props.createPublicSubnets ?? true;\n    const createPrivate = props.createPrivateSubnets ?? true;\n    const createIntra = props.createIntraSubnets ?? true;\n    const createDatabase = props.createDatabaseSubnets ?? true;\n    const createElasticache = props.createElasticacheSubnets ?? true;\n    const createRedshift = props.createRedshiftSubnets ?? false;\n\n    const masks = resolveSubnetMasks(props.vpcCidr, props);\n\n    const enabledGroups: {mask: number; name: string}[] = [];\n    if (createPublic) enabledGroups.push({mask: masks.public, name: 'public'});\n    if (createPrivate)\n      enabledGroups.push({mask: masks.private, name: 'private'});\n    if (createIntra) enabledGroups.push({mask: masks.intra, name: 'intra'});\n    if (createDatabase)\n      enabledGroups.push({mask: masks.database, name: 'database'});\n    if (createElasticache)\n      enabledGroups.push({mask: masks.elasticache, name: 'elasticache'});\n    if (createRedshift)\n      enabledGroups.push({mask: masks.redshift, name: 'redshift'});\n\n    validateAddressSpace(props.vpcCidr, azCount, enabledGroups);\n\n    const subnetConfiguration: ec2.SubnetConfiguration[] = [];\n\n    if (createPrivate) {\n      subnetConfiguration.push({\n        name: 'private',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.private,\n      });\n    }\n    if (createPublic) {\n      subnetConfiguration.push({\n        name: 'public',\n        subnetType: ec2.SubnetType.PUBLIC,\n        cidrMask: masks.public,\n        mapPublicIpOnLaunch: true,\n      });\n    }\n    if (createIntra) {\n      subnetConfiguration.push({\n        name: 'intra',\n        subnetType: ec2.SubnetType.PRIVATE_ISOLATED,\n        cidrMask: masks.intra,\n      });\n    }\n    if (createDatabase) {\n      subnetConfiguration.push({\n        name: 'database',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.database,\n      });\n    }\n    if (createElasticache) {\n      subnetConfiguration.push({\n        name: 'elasticache',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.elasticache,\n      });\n    }\n    if (createRedshift) {\n      subnetConfiguration.push({\n        name: 'redshift',\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        cidrMask: masks.redshift,\n      });\n    }\n\n    this.vpc = new ec2.Vpc(this, 'Vpc', {\n      vpcName: props.name,\n      maxAzs: azCount,\n      natGateways,\n      ipAddresses: ec2.IpAddresses.cidr(props.vpcCidr),\n      subnetConfiguration,\n      ...(props.enableIpv6\n        ? {\n            ipProtocol: ec2.IpProtocol.DUAL_STACK,\n          }\n        : {}),\n    });\n\n    if (useNatInstance) {\n      if (!createPublic) {\n        throw new Error(\"natType 'natInstance' requires public subnets.\");\n      }\n\n      // Get private subnets (PRIVATE_WITH_EGRESS type) for NAT routing.\n      // This includes: private, database, elasticache, and redshift subnet groups.\n      // This does NOT include: intra subnets (which are PRIVATE_ISOLATED and have no internet access).\n      const allPrivateSubnets = this.vpc.privateSubnets as ec2.Subnet[];\n\n      if (allPrivateSubnets.length === 0) {\n        throw new Error(\n          \"natType 'natInstance' requires at least one private subnet.\",\n        );\n      }\n\n      // Collect all private subnet CIDR blocks for security group rules\n      const privateCidrBlocks = allPrivateSubnets.map((s) => s.ipv4CidrBlock);\n\n      // Get private subnet route tables for NAT routing\n      const routeTableIds = allPrivateSubnets.map(\n        (s) => s.routeTable.routeTableId,\n      );\n\n      // The NAT instance's primary interface will receive an auto-assigned\n      // public IP from the public subnet, enabling immediate Internet egress.\n      // For a stable outbound IP, allocate an EIP and associate it with the\n      // instance's primary interface using ASG lifecycle hooks or tags.\n      new NatInstance(this, 'Nat', {\n        vpc: this.vpc,\n        publicSubnet: this.vpc.selectSubnets({subnetGroupName: 'public'})\n          .subnets[0],\n        privateSubnetCidrBlocks: privateCidrBlocks,\n        privateRouteTableIds: routeTableIds,\n      });\n    }\n\n    // Apply per-subnet-group tags\n    if (props.publicSubnetTags && createPublic) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'public'}).subnets,\n        props.publicSubnetTags,\n      );\n    }\n    if (props.privateSubnetTags && createPrivate) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'private'}).subnets,\n        props.privateSubnetTags,\n      );\n    }\n    if (props.intraSubnetTags && createIntra) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'intra'}).subnets,\n        props.intraSubnetTags,\n      );\n    }\n    if (props.databaseSubnetTags && createDatabase) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'database'}).subnets,\n        props.databaseSubnetTags,\n      );\n    }\n    if (props.elasticacheSubnetTags && createElasticache) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'elasticache'}).subnets,\n        props.elasticacheSubnetTags,\n      );\n    }\n    if (props.redshiftSubnetTags && createRedshift) {\n      applySubnetTags(\n        this.vpc.selectSubnets({subnetGroupName: 'redshift'}).subnets,\n        props.redshiftSubnetTags,\n      );\n    }\n\n    // Build the list of subnet groups for gateway endpoint route tables.\n    const endpointSubnets: ec2.SubnetSelection[] = [];\n    if (createPrivate) endpointSubnets.push({subnetGroupName: 'private'});\n    if (createIntra) endpointSubnets.push({subnetGroupName: 'intra'});\n    if (createDatabase) endpointSubnets.push({subnetGroupName: 'database'});\n    if (createElasticache)\n      endpointSubnets.push({subnetGroupName: 'elasticache'});\n    if (createRedshift) endpointSubnets.push({subnetGroupName: 'redshift'});\n\n    if ((props.createS3Endpoint ?? true) && endpointSubnets.length > 0) {\n      this.vpc.addGatewayEndpoint('S3GatewayEndpoint', {\n        service: ec2.GatewayVpcEndpointAwsService.S3,\n        subnets: endpointSubnets,\n      });\n    }\n\n    if ((props.createDynamoDbEndpoint ?? true) && endpointSubnets.length > 0) {\n      this.vpc.addGatewayEndpoint('DynamoDbGatewayEndpoint', {\n        service: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n        subnets: endpointSubnets,\n      });\n    }\n\n    // CloudFormation outputs\n    if (props.createOutputs ?? true) {\n      const stackName = Stack.of(this).stackName;\n\n      new CfnOutput(this, 'VpcId', {\n        value: this.vpc.vpcId,\n        exportName: `${stackName}:VpcId`,\n      });\n\n      if (createPublic) {\n        new CfnOutput(this, 'PublicSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'public'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:PublicSubnetIds`,\n        });\n      }\n      if (createPrivate) {\n        new CfnOutput(this, 'PrivateSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'private'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:PrivateSubnetIds`,\n        });\n      }\n      if (createIntra) {\n        new CfnOutput(this, 'IntraSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'intra'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:IntraSubnetIds`,\n        });\n      }\n      if (createDatabase) {\n        new CfnOutput(this, 'DatabaseSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'database'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:DatabaseSubnetIds`,\n        });\n      }\n      if (createElasticache) {\n        new CfnOutput(this, 'ElasticacheSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'elasticache'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:ElasticacheSubnetIds`,\n        });\n      }\n      if (createRedshift) {\n        new CfnOutput(this, 'RedshiftSubnetIds', {\n          value: this.vpc\n            .selectSubnets({subnetGroupName: 'redshift'})\n            .subnetIds.join(','),\n          exportName: `${stackName}:RedshiftSubnetIds`,\n        });\n      }\n    }\n\n    // SSM Parameter Store via NetworkParameters\n    if (props.storeParameters ?? true) {\n      this.networkParameters = new NetworkParameters(\n        this,\n        'NetworkParameters',\n        {\n          name: props.name,\n          prefix: props.parametersPrefix,\n          create: true,\n          lookupVpc: false,\n          lookupAzs: false,\n          lookupPublicSubnets: false,\n          lookupPrivateSubnets: false,\n          lookupIntraSubnets: false,\n          lookupDatabaseSubnets: false,\n          lookupElasticacheSubnets: false,\n          lookupRedshiftSubnets: false,\n          lookupOutpostSubnets: false,\n          vpcId: this.vpc.vpcId,\n          azs: this.vpc.availabilityZones,\n          publicSubnetIds: createPublic\n            ? this.vpc.selectSubnets({subnetGroupName: 'public'}).subnetIds\n            : undefined,\n          privateSubnetIds: createPrivate\n            ? this.vpc.selectSubnets({subnetGroupName: 'private'}).subnetIds\n            : undefined,\n          intraSubnetIds: createIntra\n            ? this.vpc.selectSubnets({subnetGroupName: 'intra'}).subnetIds\n            : undefined,\n          databaseSubnetIds: createDatabase\n            ? this.vpc.selectSubnets({subnetGroupName: 'database'}).subnetIds\n            : undefined,\n          elasticacheSubnetIds: createElasticache\n            ? this.vpc.selectSubnets({subnetGroupName: 'elasticache'}).subnetIds\n            : undefined,\n          redshiftSubnetIds: createRedshift\n            ? this.vpc.selectSubnets({subnetGroupName: 'redshift'}).subnetIds\n            : undefined,\n        },\n      );\n    }\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "truemark-cdk-lib",
   "description": "AWS CDK constructs created by TrueMark",
-  "version": "1.28.1",
+  "version": "1.28.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "typesVersions": {