@cdkd/cli 0.0.1 → 0.323.0

package/dist/aws-failure-text-DiHodi76.js

@@ -0,0 +1,1158 @@
+import { createHash } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/utils/display-safe.ts
+const UNRENDERABLE = "<unrenderable>";
+function toDisplayText(value) {
+	if (value === void 0 || value === null) return "";
+	try {
+		return String(value);
+	} catch {
+		try {
+			return Object.prototype.toString.call(value);
+		} catch {
+			return UNRENDERABLE;
+		}
+	}
+}
+function sanitizeAsciiOnly(text) {
+	return text.replace(/[^ -~]/g, " ").trim();
+}
+function displaySafe(value, opts) {
+	const text = toDisplayText(value);
+	if (text === "") return "";
+	if (opts?.asciiOnly) return sanitizeAsciiOnly(text);
+	return text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g, " ").trim();
+}
+const JSON_PAYLOAD_ESCAPED = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu;
+function stringifyJsonPayload(value) {
+	return JSON.stringify(value, null, 2).replace(JSON_PAYLOAD_ESCAPED, (match) => {
+		if (match === "\n") return match;
+		let out = "";
+		for (let i = 0; i < match.length; i++) out += `\\u${match.charCodeAt(i).toString(16).padStart(4, "0")}`;
+		return out;
+	});
+}
+const OWN_SGR = /^\x1b\[(?:0|1|2|3[1-6]|90)m$/;
+const SGR_RESET = "\x1B[0m";
+const CSI = String.raw`\x1b\[[0-?]*[ -/]*[@-~]|\x9b[0-?]*[ -/]*[@-~]`;
+const OSC = String.raw`\x1b\][^\x07\x1b\x9c]*(?:\x07|\x1b\\|\x9c)`;
+const CONTROL_EXCEPT_NEWLINE_AND_TAB = String.raw`[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]`;
+const TERMINAL_UNSAFE = new RegExp(`${CSI}|${CONTROL_EXCEPT_NEWLINE_AND_TAB}`, "g");
+const SAFE_MSG_ALTERED_CHAR = new RegExp(`${CONTROL_EXCEPT_NEWLINE_AND_TAB}|[\\t\\n]`);
+const TERMINAL_UNSAFE_OR_LINE_BREAK = new RegExp(`${CSI}|${OSC}|${CONTROL_EXCEPT_NEWLINE_AND_TAB}|[\\t\\n]`, "g");
+function replaceUnsafe(text, pattern) {
+	return text.replace(pattern, (match) => {
+		if (match.length === 1) return " ";
+		if (OWN_SGR.test(match)) return match;
+		return match.endsWith("m") ? SGR_RESET : "";
+	});
+}
+function terminalSafe(text) {
+	return replaceUnsafe(text, TERMINAL_UNSAFE);
+}
+var AsIsMessage = class {
+	text;
+	constructor(text) {
+		this.text = text;
+	}
+};
+function safeMsg(strings, ...values) {
+	let out = strings[0] ?? "";
+	values.forEach((value, i) => {
+		out += (value instanceof AsIsMessage ? value.text : replaceUnsafe(toDisplayText(value), TERMINAL_UNSAFE_OR_LINE_BREAK)) + strings[i + 1];
+	});
+	return out;
+}
+function asIsMessage(text) {
+	return new AsIsMessage(text);
+}
+function truncateCodePoints(text, maxCodePoints) {
+	const codePoints = Array.from(text);
+	if (codePoints.length <= maxCodePoints) return {
+		text,
+		truncated: false
+	};
+	return {
+		text: codePoints.slice(0, maxCodePoints).join(""),
+		truncated: true
+	};
+}
+const IDENT_MAX_CODE_POINTS = 255;
+const STACK_REF_MAX_CODE_POINTS = 1152;
+const SECRET_REF_MAX_CODE_POINTS = 2048;
+const AWS_MESSAGE_MAX_CODE_POINTS = 4096;
+function displayAwsMessage(value) {
+	const sanitized = displaySafe(value);
+	const { text, truncated } = truncateCodePoints(sanitized, AWS_MESSAGE_MAX_CODE_POINTS);
+	if (!truncated) return text;
+	return `${text} ${cutMarker(Array.from(sanitized).length - Array.from(text).length)}`;
+}
+const CUT_DIGEST_HEX_CHARS = 32;
+function cutMarker(withheld, digestOf) {
+	return `[cut: ${withheld} more characters withheld${digestOf === void 0 ? "" : `, tail sha256:${createHash("sha256").update(digestOf).digest("hex").slice(0, CUT_DIGEST_HEX_CHARS)}`}]`;
+}
+const PLAIN_IDENT = /^[A-Za-z0-9:_@./+=,~-]+$/;
+function displayIdent(value, opts) {
+	const raw = toDisplayText(value);
+	if (raw === "") return UNRENDERABLE;
+	const clean = sanitizeAsciiOnly(raw);
+	if (!clean) return UNRENDERABLE;
+	const requested = opts?.maxCodePoints ?? 255;
+	const { text, truncated } = truncateCodePoints(clean, Number.isFinite(requested) ? Math.max(1, Math.floor(requested)) : 255);
+	const altered = clean !== raw;
+	const plain = PLAIN_IDENT.test(text) && !(opts?.listMember === true && text.includes(","));
+	const shown = !altered && plain ? text : JSON.stringify(text);
+	return truncated ? `${shown} ${cutMarker(clean.length - text.length, clean.slice(text.length))}` : shown;
+}
+function displayStackName(value) {
+	return displayIdent(value, { maxCodePoints: STACK_REF_MAX_CODE_POINTS });
+}
+function plainIdentOr(value, description, opts) {
+	return isPlainIdent(value, opts) ? value : description;
+}
+function isPlainIdent(value, opts) {
+	return !/\s/.test(value) && displayIdent(value, opts) === value;
+}
+const PASTEABLE_STATE_IDENT = /^[A-Za-z0-9][A-Za-z0-9~_.-]*$/;
+function isPasteableIdent(value) {
+	if (!PASTEABLE_STATE_IDENT.test(value)) return false;
+	return displayIdent(value, { maxCodePoints: STACK_REF_MAX_CODE_POINTS }) === value;
+}
+
+// src/provisioning/resource-name.ts
+const stackScopeStore = new AsyncLocalStorage();
+function withStackScopeBeforeStateRead(stackName, fn) {
+	return stackScopeStore.run({
+		stackName,
+		stackInstanceId: void 0,
+		nameGenerations: void 0,
+		beforeStateRead: true
+	}, fn);
+}
+function withStackScope(scope, fn) {
+	return nameGenerationStore.exit(() => stackScopeStore.run({
+		stackName: scope.stackName,
+		stackInstanceId: scope.stackInstanceId,
+		nameGenerations: scope.nameGenerations
+	}, fn));
+}
+const nameGenerationStore = new AsyncLocalStorage();
+function isNameGeneration(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function withNameGeneration(binding, fn) {
+	if (!isNameGeneration(binding.generation)) throw new Error(`cdkd internal error: name generation ${String(binding.generation)} for ${binding.logicalId} is not a non-negative integer`);
+	return nameGenerationStore.run({
+		logicalId: binding.logicalId,
+		generation: binding.generation
+	}, fn);
+}
+function currentNameGeneration(logicalId) {
+	const bound = nameGenerationStore.getStore();
+	if (bound !== void 0 && bound.logicalId === logicalId) return bound.generation;
+	const scope = stackScopeStore.getStore();
+	if (scope?.nameGenerations === void 0) return scope?.stackInstanceId === void 0 ? 0 : void 0;
+	return scope.nameGenerations.get(logicalId) ?? 0;
+}
+function getCurrentStackName() {
+	return stackScopeStore.getStore()?.stackName;
+}
+function isBeforeStateRead() {
+	return stackScopeStore.getStore()?.beforeStateRead === true;
+}
+function getCurrentStackInstanceId() {
+	return stackScopeStore.getStore()?.stackInstanceId;
+}
+const skipPrefixStore = new AsyncLocalStorage();
+function withSkipPrefix(skip, fn) {
+	return skipPrefixStore.run(skip, fn);
+}
+function getCurrentSkipPrefix() {
+	return skipPrefixStore.getStore() ?? false;
+}
+const PATTERN_B_RESOURCE_TYPES = [
+	"AWS::IAM::Role",
+	"AWS::IAM::User",
+	"AWS::IAM::Group",
+	"AWS::IAM::InstanceProfile",
+	"AWS::IAM::ManagedPolicy",
+	"AWS::ElasticLoadBalancingV2::LoadBalancer",
+	"AWS::ElasticLoadBalancingV2::TargetGroup"
+];
+const PATTERN_B_NAME_PROPERTIES = {
+	"AWS::IAM::Role": "RoleName",
+	"AWS::IAM::User": "UserName",
+	"AWS::IAM::Group": "GroupName",
+	"AWS::IAM::InstanceProfile": "InstanceProfileName",
+	"AWS::IAM::ManagedPolicy": "ManagedPolicyName",
+	"AWS::ElasticLoadBalancingV2::LoadBalancer": "Name",
+	"AWS::ElasticLoadBalancingV2::TargetGroup": "Name"
+};
+const PATTERN_B_NAME_OPTIONS = {
+	"AWS::IAM::Role": { maxLength: 64 },
+	"AWS::IAM::User": { maxLength: 64 },
+	"AWS::IAM::Group": { maxLength: 128 },
+	"AWS::IAM::InstanceProfile": { maxLength: 128 },
+	"AWS::IAM::ManagedPolicy": { maxLength: 128 },
+	"AWS::ElasticLoadBalancingV2::LoadBalancer": { maxLength: 32 },
+	"AWS::ElasticLoadBalancingV2::TargetGroup": { maxLength: 32 }
+};
+function derivesPatternBName(resourceType, declared, live) {
+	if (!Object.prototype.hasOwnProperty.call(PATTERN_B_NAME_OPTIONS, resourceType)) return false;
+	if (typeof declared !== "string" || declared === "") return false;
+	if (typeof live !== "string" || live === "") return false;
+	const options = PATTERN_B_NAME_OPTIONS[resourceType];
+	return [true, false].some((skip) => withSkipPrefix(skip, () => generateResourceName(declared, {
+		...options,
+		userSupplied: true
+	})) === live);
+}
+const STACK_INSTANCE_SUFFIX_LENGTH = 12;
+const MAX_RECOGNIZED_GENERATION = 1024;
+function stackInstanceNameSuffix(stackInstanceId, name, generation = 0) {
+	const hash = createHash("sha256").update(stackInstanceId).update("\0").update(name);
+	if (generation !== 0) hash.update("\0").update(String(generation));
+	return hash.digest("hex").substring(0, 12);
+}
+function generateResourceName(name, options) {
+	const scope = stackScopeStore.getStore();
+	if (scope?.beforeStateRead === true && options.userSupplied !== true) throw new Error(`cdkd internal error: a generated name for ${name} was derived before the state record of ${scope.stackName} was read, so it cannot carry the stack's instance id`);
+	let generation = 0;
+	if (scope?.stackInstanceId !== void 0 && options.userSupplied !== true) {
+		const known = currentNameGeneration(name);
+		if (known === void 0) throw new Error(`cdkd internal error: a generated name for ${name} was derived in a scope of ${scope.stackName} that carries no name generations, so it could name the resource after an earlier generation`);
+		generation = known;
+	}
+	return deriveResourceName(name, options, scope?.stackName, scope?.stackInstanceId, generation);
+}
+function deriveResourceName(name, options, currentStackName, stackInstanceId, generation = 0) {
+	const { maxLength, lowercase = false, allowedPattern = /[^a-zA-Z0-9-]/g, userSupplied = false } = options;
+	const shouldPrefix = currentStackName && !(userSupplied && getCurrentSkipPrefix());
+	const fullName = shouldPrefix ? `${currentStackName}-${name}` : name;
+	let sanitized = lowercase ? fullName.toLowerCase() : fullName;
+	sanitized = sanitized.replace(allowedPattern, "-");
+	sanitized = sanitized.replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+	if (shouldPrefix && !userSupplied && stackInstanceId !== void 0) {
+		const suffix = stackInstanceNameSuffix(stackInstanceId, name, generation);
+		const base = sanitized.substring(0, maxLength - suffix.length - 1).replace(/-+$/, "");
+		return base === "" ? suffix : `${base}-${suffix}`;
+	}
+	if (sanitized.length <= maxLength) return sanitized;
+	const hash = createHash("sha256").update(fullName).digest("hex").substring(0, 8);
+	const maxPrefixLength = maxLength - hash.length - 1;
+	return `${sanitized.substring(0, maxPrefixLength).replace(/-+$/, "")}-${hash}`;
+}
+function looksLikeCdkdGeneratedName(physicalId, logicalId, stackName, stackInstanceId, generations) {
+	if (!physicalId || !logicalId || !stackName) return false;
+	const skeleton = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+	const derived = skeleton(`${stackName}-${logicalId}`);
+	if (skeleton(physicalId) === derived) return true;
+	if (stackInstanceId !== void 0) {
+		const suffixed = /^(.*)-([0-9a-f]{12})$/.exec(physicalId.toLowerCase());
+		if (suffixed !== null) {
+			const base = skeleton(suffixed[1]);
+			const through = Math.min(generations?.through ?? (currentNameGeneration(logicalId) ?? 0) + 1, MAX_RECOGNIZED_GENERATION);
+			for (let g = 0; g <= through; g++) {
+				if (suffixed[2] !== stackInstanceNameSuffix(stackInstanceId, logicalId, g)) continue;
+				if (base.length > 0 && derived.startsWith(base)) return true;
+			}
+		}
+	}
+	const truncated = /^(.*)-([0-9a-f]{8})$/.exec(physicalId.toLowerCase());
+	if (!truncated) return false;
+	const prefix = skeleton(truncated[1]);
+	return prefix.length > 0 && derived.startsWith(prefix);
+}
+function generateResourceNameWithFallback(userSuppliedName, logicalId, options) {
+	if (userSuppliedName !== void 0 && userSuppliedName !== "") return generateResourceName(userSuppliedName, {
+		...options,
+		userSupplied: true
+	});
+	return generateResourceName(logicalId, {
+		...options,
+		userSupplied: false
+	});
+}
+function isDeclaredName(value) {
+	return value !== void 0 && value !== "";
+}
+function isGeneratedNameOfEitherScheme(recorded, logicalId, options) {
+	const scope = stackScopeStore.getStore();
+	if (!scope?.stackName || recorded === "") return false;
+	const opts = {
+		...options,
+		userSupplied: false
+	};
+	if (recorded === deriveResourceName(logicalId, opts, scope.stackName, void 0)) return true;
+	const probe = deriveResourceName(logicalId, opts, scope.stackName, "00000000-0000-4000-8000-000000000000");
+	const base = probe.slice(0, probe.length - 12);
+	return recorded.startsWith(base) && /^[0-9a-f]{12}$/.test(recorded.slice(base.length));
+}
+function recordedGeneratedNameKept(input) {
+	if (input.derived === input.recorded) return false;
+	if (isDeclaredName(input.declaredName) || isDeclaredName(input.previousDeclaredName)) return false;
+	return isGeneratedNameOfEitherScheme(input.recorded, input.logicalId, input.options);
+}
+const FALLBACK_NAME_RULES = {
+	"AWS::S3::Bucket": {
+		nameProperty: "BucketName",
+		options: {
+			maxLength: 63,
+			lowercase: true,
+			allowedPattern: /[^a-z0-9.-]/g
+		}
+	},
+	"AWS::SQS::Queue": {
+		nameProperty: "QueueName",
+		options: { maxLength: 80 }
+	},
+	"AWS::SNS::Topic": {
+		nameProperty: "TopicName",
+		options: { maxLength: 256 }
+	},
+	"AWS::Lambda::Function": {
+		nameProperty: "FunctionName",
+		options: { maxLength: 64 }
+	},
+	"AWS::Lambda::LayerVersion": {
+		nameProperty: "LayerName",
+		options: { maxLength: 64 }
+	},
+	"AWS::Lambda::CapacityProvider": {
+		nameProperty: "CapacityProviderName",
+		options: { maxLength: 64 }
+	},
+	"AWS::IAM::Role": {
+		nameProperty: "RoleName",
+		options: { maxLength: 64 }
+	},
+	"AWS::IAM::Policy": {
+		nameProperty: "PolicyName",
+		options: { maxLength: 64 }
+	},
+	"AWS::IAM::ManagedPolicy": {
+		nameProperty: "ManagedPolicyName",
+		options: { maxLength: 128 }
+	},
+	"AWS::IAM::User": {
+		nameProperty: "UserName",
+		options: { maxLength: 64 }
+	},
+	"AWS::IAM::Group": {
+		nameProperty: "GroupName",
+		options: { maxLength: 128 }
+	},
+	"AWS::IAM::InstanceProfile": {
+		nameProperty: "InstanceProfileName",
+		options: { maxLength: 128 }
+	},
+	"AWS::DynamoDB::Table": {
+		nameProperty: "TableName",
+		options: { maxLength: 255 }
+	},
+	"AWS::ECR::Repository": {
+		nameProperty: "RepositoryName",
+		options: {
+			maxLength: 256,
+			lowercase: true
+		}
+	},
+	"AWS::ECS::Cluster": {
+		nameProperty: "ClusterName",
+		options: { maxLength: 255 }
+	},
+	"AWS::ECS::Service": {
+		nameProperty: "ServiceName",
+		options: { maxLength: 255 }
+	},
+	"AWS::Logs::LogGroup": {
+		nameProperty: "LogGroupName",
+		options: {
+			maxLength: 506,
+			allowedPattern: /[^a-zA-Z0-9-/_]/g
+		},
+		prefix: "/cdkd/",
+		legacy: { cloudControl: { maxLength: 512 } }
+	},
+	"AWS::CloudWatch::Alarm": {
+		nameProperty: "AlarmName",
+		options: { maxLength: 255 }
+	},
+	"AWS::Events::Rule": {
+		nameProperty: "Name",
+		options: { maxLength: 64 }
+	},
+	"AWS::Kinesis::Stream": {
+		nameProperty: "Name",
+		options: { maxLength: 128 }
+	},
+	"AWS::StepFunctions::StateMachine": {
+		nameProperty: "StateMachineName",
+		options: { maxLength: 80 }
+	},
+	"AWS::SecretsManager::Secret": {
+		nameProperty: "Name",
+		options: {
+			maxLength: 512,
+			allowedPattern: /[^a-zA-Z0-9-/_]/g
+		}
+	},
+	"AWS::SSM::Parameter": {
+		nameProperty: "Name",
+		options: {
+			maxLength: 1023,
+			allowedPattern: /[^a-zA-Z0-9-/_]/g
+		},
+		prefix: "/",
+		legacy: { cloudControl: { maxLength: 2048 } }
+	},
+	"AWS::Cognito::UserPool": {
+		nameProperty: "UserPoolName",
+		options: { maxLength: 128 }
+	},
+	"AWS::ElastiCache::SubnetGroup": {
+		nameProperty: "CacheSubnetGroupName",
+		options: {
+			maxLength: 255,
+			lowercase: true
+		}
+	},
+	"AWS::ElastiCache::CacheCluster": {
+		nameProperty: "ClusterName",
+		options: {
+			maxLength: 40,
+			lowercase: true
+		}
+	},
+	"AWS::RDS::DBSubnetGroup": {
+		nameProperty: "DBSubnetGroupName",
+		options: {
+			maxLength: 255,
+			lowercase: true
+		}
+	},
+	"AWS::RDS::DBCluster": {
+		nameProperty: "DBClusterIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::RDS::DBInstance": {
+		nameProperty: "DBInstanceIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::DocDB::DBSubnetGroup": {
+		nameProperty: "DBSubnetGroupName",
+		options: {
+			maxLength: 255,
+			lowercase: true
+		}
+	},
+	"AWS::DocDB::DBCluster": {
+		nameProperty: "DBClusterIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::DocDB::DBInstance": {
+		nameProperty: "DBInstanceIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::Neptune::DBSubnetGroup": {
+		nameProperty: "DBSubnetGroupName",
+		options: {
+			maxLength: 255,
+			lowercase: true
+		}
+	},
+	"AWS::Neptune::DBCluster": {
+		nameProperty: "DBClusterIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::Neptune::DBInstance": {
+		nameProperty: "DBInstanceIdentifier",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		}
+	},
+	"AWS::ElasticLoadBalancingV2::LoadBalancer": {
+		nameProperty: "Name",
+		options: { maxLength: 32 }
+	},
+	"AWS::ElasticLoadBalancingV2::TargetGroup": {
+		nameProperty: "Name",
+		options: { maxLength: 32 }
+	},
+	"AWS::WAFv2::WebACL": {
+		nameProperty: "Name",
+		options: { maxLength: 128 }
+	},
+	"AWS::CodeBuild::Project": {
+		nameProperty: "Name",
+		options: { maxLength: 150 },
+		legacy: { sdk: "logicalId" }
+	},
+	"AWS::S3Express::DirectoryBucket": {
+		nameProperty: "BucketName",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		},
+		zoneSuffix: true
+	},
+	"AWS::CodeCommit::Repository": {
+		nameProperty: "RepositoryName",
+		options: { maxLength: 100 }
+	},
+	"AWS::RDS::DBProxy": {
+		nameProperty: "DBProxyName",
+		options: { maxLength: 64 }
+	},
+	"AWS::RDS::DBProxyEndpoint": {
+		nameProperty: "DBProxyEndpointName",
+		options: { maxLength: 64 }
+	},
+	"AWS::S3Vectors::VectorBucket": {
+		nameProperty: "VectorBucketName",
+		options: {
+			maxLength: 63,
+			lowercase: true
+		},
+		legacy: { cloudControl: "none" },
+		notAdopted: true
+	},
+	"AWS::ServiceDiscovery::Service": {
+		nameProperty: "Name",
+		options: { maxLength: 63 },
+		legacy: { cloudControl: "none" },
+		notAdopted: true
+	},
+	"AWS::Scheduler::Schedule": {
+		nameProperty: "Name",
+		options: { maxLength: 64 },
+		legacy: { cloudControl: "none" }
+	},
+	"AWS::AutoScaling::AutoScalingGroup": {
+		nameProperty: "AutoScalingGroupName",
+		options: { maxLength: 255 },
+		legacy: { cloudControl: "none" }
+	},
+	"AWS::DynamoDB::GlobalTable": {
+		nameProperty: "TableName",
+		options: { maxLength: 255 },
+		legacy: { cloudControl: "none" }
+	},
+	"AWS::ECS::TaskDefinition": {
+		nameProperty: "Family",
+		options: { maxLength: 255 },
+		legacy: { cloudControl: "none" },
+		notAdopted: true
+	},
+	"AWS::Lambda::NetworkConnector": {
+		nameProperty: "Name",
+		options: { maxLength: 64 },
+		legacy: { cloudControl: "none" },
+		notAdopted: true
+	},
+	"AWS::Pipes::Pipe": {
+		nameProperty: "Name",
+		options: { maxLength: 64 },
+		legacy: { cloudControl: "none" },
+		notAdopted: true
+	},
+	"AWS::EC2::SecurityGroup": {
+		nameProperty: "GroupName",
+		options: { maxLength: 255 },
+		refusedPrefix: "sg-",
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::CloudTrail::Trail": {
+		nameProperty: "TrailName",
+		options: { maxLength: 128 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::Glue::Job": {
+		nameProperty: "Name",
+		options: { maxLength: 255 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::Glue::Crawler": {
+		nameProperty: "Name",
+		options: { maxLength: 255 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::Glue::Connection": {
+		nameProperty: "Name",
+		nestedIn: "ConnectionInput",
+		options: { maxLength: 255 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::Glue::Trigger": {
+		nameProperty: "Name",
+		options: { maxLength: 255 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	},
+	"AWS::KinesisFirehose::DeliveryStream": {
+		nameProperty: "DeliveryStreamName",
+		options: { maxLength: 64 },
+		legacy: {
+			sdk: "logicalId",
+			cloudControl: "none"
+		},
+		notAdopted: true
+	}
+};
+function scopeHasStackInstanceId() {
+	return stackScopeStore.getStore()?.stackInstanceId !== void 0;
+}
+function deriveRuleName(rule, logicalId, input) {
+	if (rule.zoneSuffix === true) {
+		if (input.zoneId === void 0 || input.zoneId === "") return void 0;
+		const suffix = `--${input.zoneId}--x-s3`;
+		return `${generateResourceName(logicalId, {
+			...rule.options,
+			maxLength: rule.options.maxLength - suffix.length
+		})}${suffix}`;
+	}
+	const name = `${rule.prefix ?? ""}${generateResourceName(logicalId, rule.options)}`;
+	const refused = rule.refusedPrefix;
+	if (refused !== void 0 && name.toLowerCase().startsWith(refused.toLowerCase())) return `${name.slice(0, refused.length - 1)}${name.slice(refused.length)}`;
+	return name;
+}
+function generatedNameFor(resourceType, logicalId, input = {}) {
+	const rule = FALLBACK_NAME_RULES[resourceType];
+	if (rule === void 0) throw new Error(`cdkd internal error: ${resourceType} has no generated-name rule`);
+	if (rule.legacy?.sdk === "logicalId" && !scopeHasStackInstanceId() && stackScopeStore.getStore()?.beforeStateRead !== true) return logicalId;
+	const name = deriveRuleName(rule, logicalId, input);
+	if (name === void 0) throw new Error(`cdkd internal error: the generated ${resourceType} name needs a zone id`);
+	return name;
+}
+function nameContainer(rule, properties) {
+	if (rule.nestedIn === void 0) return properties;
+	const nested = properties[rule.nestedIn];
+	return typeof nested === "object" && nested !== null && !Array.isArray(nested) ? nested : void 0;
+}
+function directoryBucketZoneId(properties) {
+	const location = properties["LocationName"];
+	if (typeof location !== "string") return void 0;
+	const zone = location.replace(/--x-s3$/, "");
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*-az[0-9]+$/.test(zone) ? zone : void 0;
+}
+function applyDefaultNameForFallback(logicalId, resourceType, properties, underivable = "refuse") {
+	const rule = FALLBACK_NAME_RULES[resourceType];
+	if (!rule) return properties;
+	const container = nameContainer(rule, properties);
+	if (container === void 0) return properties;
+	if (container[rule.nameProperty]) return properties;
+	let generatedName;
+	const legacy = scopeHasStackInstanceId() ? void 0 : rule.legacy?.cloudControl;
+	if (legacy === "none") return properties;
+	if (legacy !== void 0) generatedName = generateResourceName(logicalId, legacy);
+	else {
+		const zoneId = rule.zoneSuffix === true ? directoryBucketZoneId(properties) : void 0;
+		generatedName = deriveRuleName(rule, logicalId, zoneId === void 0 ? {} : { zoneId });
+	}
+	if (generatedName === void 0) {
+		if (underivable === "omit") return properties;
+		const location = properties["LocationName"] === void 0 ? "the resource declares no LocationName" : "its LocationName is not a zone id such as use1-az5";
+		throw new Error(`${logicalId} (${resourceType}): cdkd cannot generate a ${rule.nameProperty} for the Cloud Control create. A directory bucket's name must end with --<zone id>--x-s3, and ${location}. Set LocationName to the zone id, or declare ${rule.nameProperty}.`);
+	}
+	if (rule.nestedIn !== void 0) return {
+		...properties,
+		[rule.nestedIn]: {
+			...container,
+			[rule.nameProperty]: generatedName
+		}
+	};
+	return {
+		...properties,
+		[rule.nameProperty]: generatedName
+	};
+}
+function fallbackNamePropertyFor(resourceType) {
+	const rule = FALLBACK_NAME_RULES[resourceType];
+	return rule?.nestedIn === void 0 ? rule?.nameProperty : void 0;
+}
+function withoutGeneratedFallbackName(resourceType, resolvedProps, prepared) {
+	const rule = FALLBACK_NAME_RULES[resourceType];
+	if (rule?.nestedIn !== void 0) {
+		const outer = rule.nestedIn;
+		const resolvedInner = nameContainer(rule, resolvedProps);
+		const preparedInner = nameContainer(rule, prepared);
+		if (resolvedInner === void 0 || preparedInner === void 0) return prepared;
+		const inner = withoutGeneratedFallbackNameAt(rule.nameProperty, resolvedInner, preparedInner);
+		return inner === preparedInner ? prepared : {
+			...prepared,
+			[outer]: inner
+		};
+	}
+	const nameProperty = fallbackNamePropertyFor(resourceType);
+	if (nameProperty === void 0) return prepared;
+	return withoutGeneratedFallbackNameAt(nameProperty, resolvedProps, prepared);
+}
+function withoutGeneratedFallbackNameAt(nameProperty, resolvedProps, prepared) {
+	if (resolvedProps[nameProperty] || !(nameProperty in prepared)) return prepared;
+	const restored = { ...prepared };
+	if (nameProperty in resolvedProps) restored[nameProperty] = resolvedProps[nameProperty];
+	else delete restored[nameProperty];
+	return restored;
+}
+function explicitNamePropertyFor(resourceType) {
+	const rule = FALLBACK_NAME_RULES[resourceType];
+	if (rule !== void 0 && rule.notAdopted !== true) return rule.nameProperty;
+	return ADOPTION_ONLY_NAME_PROPERTIES[resourceType];
+}
+const ADOPTION_ONLY_NAME_PROPERTIES = { "AWS::Events::EventBus": "Name" };
+function alternateNamePropertiesFor(resourceType) {
+	return resourceType === "AWS::S3::Bucket" ? ["BucketNamePrefix"] : [];
+}
+
+// src/utils/live-renderer.ts
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const FRAME_INTERVAL_MS = 80;
+const ESC = "\x1B[";
+function scopedKey(id, stackName) {
+	return stackName ? `${stackName}:${id}` : id;
+}
+var LiveRenderer = class {
+	tasks = /* @__PURE__ */ new Map();
+	active = false;
+	suspended = false;
+	spinnerIndex = 0;
+	interval = null;
+	linesDrawn = 0;
+	cursorHidden = false;
+	exitListener = null;
+	stream;
+	constructor(stream = process.stdout) {
+		this.stream = stream;
+	}
+	isActive() {
+		return this.active;
+	}
+	start() {
+		if (this.active) return true;
+		if (!this.stream.isTTY) return false;
+		if (process.env["CDKD_NO_LIVE"] === "1") return false;
+		this.active = true;
+		this.hideCursor();
+		if (!this.exitListener) {
+			this.exitListener = () => this.showCursor();
+			process.on("exit", this.exitListener);
+		}
+		this.interval = setInterval(() => this.draw(), FRAME_INTERVAL_MS);
+		if (typeof this.interval.unref === "function") this.interval.unref();
+		return true;
+	}
+	stop() {
+		if (!this.active) return;
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+		this.clear();
+		this.showCursor();
+		if (this.exitListener) {
+			process.removeListener("exit", this.exitListener);
+			this.exitListener = null;
+		}
+		this.tasks.clear();
+		this.active = false;
+	}
+	addTask(id, label) {
+		const stackName = getCurrentStackName();
+		this.tasks.set(scopedKey(id, stackName), {
+			label,
+			startedAt: Date.now(),
+			stackName
+		});
+		if (this.active) this.draw();
+	}
+	removeTask(id) {
+		const stackName = getCurrentStackName();
+		if (!this.tasks.delete(scopedKey(id, stackName))) return;
+		if (this.active) this.draw();
+	}
+	updateTaskLabel(id, label) {
+		const stackName = getCurrentStackName();
+		const task = this.tasks.get(scopedKey(id, stackName));
+		if (!task) return;
+		task.label = label;
+		if (this.active) this.draw();
+	}
+	printAbove(write) {
+		if (!this.active || this.suspended) {
+			write();
+			return;
+		}
+		this.clear();
+		write();
+		this.draw();
+	}
+	clear() {
+		if (this.linesDrawn === 0) return;
+		this.stream.write("\r");
+		for (let i = 0; i < this.linesDrawn; i++) this.stream.write(`${ESC}1A${ESC}2K`);
+		this.linesDrawn = 0;
+	}
+	async suspendWhile(fn) {
+		if (!this.active || this.suspended) return fn();
+		this.suspended = true;
+		this.clear();
+		this.showCursor();
+		try {
+			return await fn();
+		} finally {
+			this.suspended = false;
+			if (this.active) {
+				this.hideCursor();
+				this.draw();
+			}
+		}
+	}
+	draw() {
+		if (!this.active || this.suspended) return;
+		this.clear();
+		if (this.tasks.size === 0) return;
+		const frame = SPINNER_FRAMES[this.spinnerIndex % SPINNER_FRAMES.length];
+		this.spinnerIndex++;
+		const distinctStacks = /* @__PURE__ */ new Set();
+		for (const task of this.tasks.values()) distinctStacks.add(task.stackName);
+		const showStackPrefix = distinctStacks.size > 1;
+		const cols = this.stream.columns ?? 80;
+		const lines = [];
+		for (const task of this.tasks.values()) {
+			const elapsed = ((Date.now() - task.startedAt) / 1e3).toFixed(1);
+			const raw = `  ${frame} ${showStackPrefix && task.stackName ? `[${displayStackName(task.stackName)}] ` : ""}${displaySafe(task.label)} (${elapsed}s)`;
+			lines.push(this.truncate(raw, cols));
+		}
+		this.stream.write(lines.join("\n") + "\n");
+		this.linesDrawn = lines.length;
+	}
+	truncate(s, maxLen) {
+		if (s.length <= maxLen) return s;
+		if (maxLen <= 1) return "…";
+		return s.substring(0, maxLen - 1) + "…";
+	}
+	hideCursor() {
+		if (this.cursorHidden) return;
+		this.stream.write(`${ESC}?25l`);
+		this.cursorHidden = true;
+	}
+	showCursor() {
+		if (!this.cursorHidden) return;
+		this.stream.write(`${ESC}?25h`);
+		this.cursorHidden = false;
+	}
+};
+let globalRenderer = null;
+function getLiveRenderer() {
+	if (!globalRenderer) globalRenderer = new LiveRenderer();
+	return globalRenderer;
+}
+
+// src/utils/log-line-masker.ts
+let source;
+function installLogLineMaskerSource(next) {
+	if (source !== void 0) throw new Error("log line masker source is already installed");
+	source = next;
+}
+function currentLogLineMasker() {
+	return source?.();
+}
+
+// src/utils/stack-context.ts
+const outputBufferStore = new AsyncLocalStorage();
+async function runStackBuffered(fn) {
+	const buffer = { lines: [] };
+	return outputBufferStore.run(buffer, async () => {
+		try {
+			return {
+				ok: true,
+				result: await fn(),
+				lines: buffer.lines
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error,
+				lines: buffer.lines
+			};
+		}
+	});
+}
+function getCurrentStackOutputBuffer() {
+	return outputBufferStore.getStore();
+}
+
+// src/utils/logger.ts
+const colors = {
+	reset: "\x1B[0m",
+	bright: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	cyan: "\x1B[36m",
+	gray: "\x1B[90m"
+};
+let stdoutReservedForPayload = false;
+function reserveStdoutForPayload() {
+	stdoutReservedForPayload = true;
+}
+function isStdoutReservedForPayload() {
+	return stdoutReservedForPayload;
+}
+function renderArgs(args, mask) {
+	if (mask === void 0) return args.map((a) => JSON.stringify(a)).join(" ");
+	const rebuilt = /* @__PURE__ */ new WeakMap();
+	const replacer = (_key, value) => {
+		if (typeof value === "string") return mask(value);
+		if (value instanceof String) return mask(String(value));
+		if (typeof value === "number") {
+			const masked = mask(String(value));
+			return masked === String(value) ? value : masked;
+		}
+		if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+		const seen = rebuilt.get(value);
+		if (seen !== void 0) return seen;
+		const entries = Object.entries(value);
+		if (entries.every(([k]) => mask(k) === k)) return value;
+		const copy = Object.create(null);
+		for (const [k, v] of entries) {
+			let key = mask(k);
+			for (let n = 2; Object.hasOwn(copy, key); n++) key = `${mask(k)}#${n}`;
+			copy[key] = v;
+		}
+		rebuilt.set(value, copy);
+		return copy;
+	};
+	return args.map((a) => JSON.stringify(a, replacer)).join(" ");
+}
+function formatTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+var ConsoleLogger = class {
+	level;
+	useColors;
+	constructor(level = "info", useColors = true) {
+		this.level = level;
+		this.useColors = useColors;
+	}
+	shouldLog(level) {
+		const levels = [
+			"debug",
+			"info",
+			"warn",
+			"error"
+		];
+		const currentLevelIndex = levels.indexOf(this.level);
+		return levels.indexOf(level) >= currentLevelIndex;
+	}
+	formatMessage(level, message, ...args) {
+		const mask = currentLogLineMasker();
+		const formattedArgs = args.length > 0 ? " " + displaySafe(renderArgs(args, mask)) : "";
+		message = terminalSafe(mask === void 0 ? message : mask(message));
+		if (this.level === "debug") {
+			const timestamp = formatTimestamp();
+			const levelStr = level.toUpperCase().padEnd(5);
+			if (this.useColors) {
+				const levelColor = {
+					debug: colors.gray,
+					info: colors.blue,
+					warn: colors.yellow,
+					error: colors.red
+				}[level];
+				return `${colors.dim}${timestamp}${colors.reset} ${levelColor}${levelStr}${colors.reset} ${message}${formattedArgs}`;
+			}
+			return `${timestamp} ${levelStr} ${message}${formattedArgs}`;
+		}
+		if (this.useColors) {
+			if (level === "error") return `${colors.red}${message}${formattedArgs}${colors.reset}`;
+			if (level === "warn") return `${colors.yellow}${message}${formattedArgs}${colors.reset}`;
+			return `${message}${formattedArgs}`;
+		}
+		return `${message}${formattedArgs}`;
+	}
+	emit(level, formatted) {
+		const buffer = getCurrentStackOutputBuffer();
+		if (buffer) {
+			buffer.lines.push(formatted);
+			return;
+		}
+		getLiveRenderer().printAbove(() => {
+			if (level === "error") console.error(formatted);
+			else if (level === "warn") console.warn(formatted);
+			else if (stdoutReservedForPayload) console.error(formatted);
+			else if (level === "info") console.info(formatted);
+			else console.debug(formatted);
+		});
+	}
+	debug(message, ...args) {
+		if (this.shouldLog("debug")) this.emit("debug", this.formatMessage("debug", message, ...args));
+	}
+	info(message, ...args) {
+		if (this.shouldLog("info")) this.emit("info", this.formatMessage("info", message, ...args));
+	}
+	warn(message, ...args) {
+		if (this.shouldLog("warn")) this.emit("warn", this.formatMessage("warn", message, ...args));
+	}
+	error(message, ...args) {
+		if (this.shouldLog("error")) this.emit("error", this.formatMessage("error", message, ...args));
+	}
+	setLevel(level) {
+		this.level = level;
+	}
+	getLevel() {
+		return this.level;
+	}
+	child(prefix) {
+		return new ChildLogger(prefix, this.useColors);
+	}
+};
+var ChildLogger = class extends ConsoleLogger {
+	prefix;
+	constructor(prefix, useColors) {
+		super("info", useColors);
+		this.prefix = prefix;
+	}
+	syncLevel() {
+		if (globalLogger) this.setLevel(globalLogger.getLevel());
+	}
+	debug(message, ...args) {
+		this.syncLevel();
+		super.debug(`[${this.prefix}] ${message}`, ...args);
+	}
+	info(message, ...args) {
+		this.syncLevel();
+		const msg = this.getLevel() === "debug" ? `[${this.prefix}] ${message}` : message;
+		super.info(msg, ...args);
+	}
+	warn(message, ...args) {
+		this.syncLevel();
+		const msg = this.getLevel() === "debug" ? `[${this.prefix}] ${message}` : message;
+		super.warn(msg, ...args);
+	}
+	error(message, ...args) {
+		this.syncLevel();
+		const msg = this.getLevel() === "debug" ? `[${this.prefix}] ${message}` : message;
+		super.error(msg, ...args);
+	}
+};
+let globalLogger = null;
+function getLogger() {
+	if (!globalLogger) globalLogger = new ConsoleLogger();
+	return globalLogger;
+}
+function setLogger(logger) {
+	globalLogger = logger;
+}
+
+// src/utils/aws-failure-text.ts
+const VERBOSE_POINTER = "Re-run with --verbose for AWS's own message.";
+function redactedAwsFailureSummary(error) {
+	const raw = error.name;
+	return `${(raw ? safeStringify(raw) : "") || "Error"}. ${VERBOSE_POINTER}`;
+}
+function isAwsAuthoredFailure(error) {
+	const candidate = error;
+	return candidate.$fault !== void 0 || typeof candidate.$metadata?.httpStatusCode === "number" || error.name === "CredentialsProviderError";
+}
+function safeStringify(value) {
+	try {
+		return String(value);
+	} catch {
+		return "a value that could not be converted to text";
+	}
+}
+function describeAwsFailure(error) {
+	if (error instanceof Error) {
+		if (!isAwsAuthoredFailure(error)) return {
+			summary: error.message,
+			detail: error.message,
+			redacted: false
+		};
+		return {
+			summary: redactedAwsFailureSummary(error),
+			detail: error.message,
+			redacted: true
+		};
+	}
+	let detail;
+	try {
+		detail = String(error);
+	} catch {
+		detail = "a value that could not be converted to text";
+	}
+	return {
+		summary: `a non-Error value of type ${typeof error}. ${VERBOSE_POINTER}`,
+		detail,
+		redacted: true
+	};
+}
+function describeAwsStatusReason(reason, fallback) {
+	const message = reason?.message;
+	if (message === void 0 || message === "") return {
+		summary: fallback,
+		detail: fallback,
+		redacted: false
+	};
+	const code = reason?.code;
+	return {
+		summary: `${code ? `${code}. ` : ""}${VERBOSE_POINTER}`,
+		detail: message,
+		redacted: true
+	};
+}
+
+export { safeMsg as $, isBeforeStateRead as A, SAFE_MSG_ALTERED_CHAR as B, fallbackNamePropertyFor as C, getCurrentSkipPrefix as D, generatedNameFor as E, withNameGeneration as F, cutMarker as G, STACK_REF_MAX_CODE_POINTS as H, withSkipPrefix as I, displaySafe as J, displayAwsMessage as K, withStackScope as L, looksLikeCdkdGeneratedName as M, recordedGeneratedNameKept as N, getCurrentStackInstanceId as O, stackInstanceNameSuffix as P, plainIdentOr as Q, withStackScopeBeforeStateRead as R, explicitNamePropertyFor as S, generateResourceNameWithFallback as T, UNRENDERABLE as U, SECRET_REF_MAX_CODE_POINTS as V, asIsMessage as W, isPasteableIdent as X, displayStackName as Y, isPlainIdent as Z, PATTERN_B_RESOURCE_TYPES as _, safeStringify as a, currentNameGeneration as b, isStdoutReservedForPayload as c, runStackBuffered as d, stringifyJsonPayload as et, currentLogLineMasker as f, PATTERN_B_NAME_PROPERTIES as g, PATTERN_B_NAME_OPTIONS as h, isAwsAuthoredFailure as i, isNameGeneration as j, getCurrentStackName as k, reserveStdoutForPayload as l, getLiveRenderer as m, describeAwsFailure as n, truncateCodePoints as nt, ConsoleLogger as o, installLogLineMaskerSource as p, displayIdent as q, describeAwsStatusReason as r, getLogger as s, VERBOSE_POINTER as t, terminalSafe as tt, setLogger as u, alternateNamePropertiesFor as v, generateResourceName as w, derivesPatternBName as x, applyDefaultNameForFallback as y, withoutGeneratedFallbackName as z };
+//# sourceMappingURL=aws-failure-text-DiHodi76.js.map