@go-to-k/cdkd 0.123.0 → 0.124.0

package/README.md

@@ -552,11 +552,14 @@ adopt nor recreate them).
 cdkd export MyStack                           # confirmation prompt; CFn stack name = cdkd stack name
 cdkd export MyStack --cfn-stack-name MyStack-CFn
 cdkd export MyStack --dry-run                 # print the import plan, do not call CFn
-cdkd export MyStack --template path.json      # skip synth, use a pre-rendered JSON template
+cdkd export MyStack --template path.json      # skip synth, use a pre-rendered template (JSON or YAML — format auto-detected)
 cdkd export MyStack --include-non-importable  # 2-phase: IMPORT importable + CFn-CREATE Custom Resources
 ```
 
-MVP scope: JSON templates only (CDK-generated).
+Accepts JSON and YAML templates. YAML round-trips through a CFn-aware codec
+(`src/cli/yaml-cfn.ts`) that preserves every shorthand intrinsic (`!Ref` /
+`!GetAtt` / `!Sub` / `!Join` / etc.), so a YAML-authored CFn stack stays YAML
+on the phase-1 IMPORT and phase-2 UPDATE changesets.
 
 ## Drift detection
 

package/dist/cli.js

@@ -56,6 +56,7 @@ import { CreateVectorBucketCommand, DeleteIndexCommand, DeleteVectorBucketComman
 import { CreateNamespaceCommand, CreateTableBucketCommand, CreateTableCommand as CreateTableCommand$2, DeleteNamespaceCommand as DeleteNamespaceCommand$1, DeleteTableBucketCommand, DeleteTableCommand as DeleteTableCommand$2, GetTableBucketCommand, GetTableCommand as GetTableCommand$1, ListNamespacesCommand as ListNamespacesCommand$1, ListTableBucketsCommand, ListTablesCommand as ListTablesCommand$1, ListTagsForResourceCommand as ListTagsForResourceCommand$19, NotFoundException as NotFoundException$5, S3TablesClient } from "@aws-sdk/client-s3tables";
 import { AttachTrafficSourcesCommand, AutoScalingClient, CreateAutoScalingGroupCommand, DeleteAutoScalingGroupCommand, DeleteLifecycleHookCommand, DeleteNotificationConfigurationCommand, DescribeAutoScalingGroupsCommand, DescribeLifecycleHooksCommand, DescribeNotificationConfigurationsCommand, DescribeTrafficSourcesCommand, DetachTrafficSourcesCommand, DisableMetricsCollectionCommand, EnableMetricsCollectionCommand, PutLifecycleHookCommand, PutNotificationConfigurationCommand, UpdateAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling";
 import * as readline from "node:readline/promises";
+import { Document, Pair, Scalar, YAMLMap, YAMLSeq, parse as parse$1, stringify } from "yaml";
 import { createServer } from "node:net";
 import { promisify } from "node:util";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -34744,6 +34745,307 @@ function createStateCommand() {
 	return cmd;
 }
 
+//#endregion
+//#region src/cli/yaml-cfn.ts
+/**
+* CloudFormation-aware YAML codec.
+*
+* Parses + serializes CFn templates while preserving every CFn shorthand
+* intrinsic tag (`!Ref`, `!GetAtt`, `!Sub`, `!Join`, ...) — generic YAML
+* libraries silently strip these tags on parse + re-emit, corrupting the
+* template. cdkd uses this codec on both directions of CFn migration:
+* `cdkd export` (cdkd → CFn IMPORT) and
+* `cdkd import --migrate-from-cloudformation` (CFn → cdkd state).
+*
+* Algorithm: each `!Foo` tag is registered as a YAML custom tag whose
+* resolver returns the long-form object shape `{Fn::Foo: <args>}` (or
+* `{Ref: <name>}` for the bare `!Ref`). On stringify, the same objects
+* are detected and emitted back to shorthand tag form. The internal
+* model cdkd carries between parse and stringify is the long-form object
+* shape — same shape JSON produces — so every downstream consumer
+* (`injectRetainPolicies`, `executeImportChangeSet`, etc.) reads one
+* representation.
+*
+* Each tag is registered three times (scalar / sequence / map) per the
+* `yaml` library's API contract — a single registration only matches one
+* collection shape. Nested intrinsics resolve recursively via
+* `node.toJSON()` (the yaml lib resolves child customTags before invoking
+* the parent resolver).
+*
+* Format detection sniffs the first non-whitespace byte: `{` or `[` →
+* JSON; anything else → YAML. Empty input rejected as JSON so the
+* caller's existing JSON-empty-input error path fires.
+*
+* Tag set supported (matches the AWS docs canonical list):
+*   `!Ref`, `!GetAtt`, `!Sub`, `!Join`, `!Select`, `!Split`,
+*   `!If`, `!Equals`, `!And`, `!Or`, `!Not`,
+*   `!FindInMap`, `!Base64`, `!Cidr`, `!GetAZs`, `!ImportValue`,
+*   `!Transform`, `!Condition` (used inside `Conditions:` references).
+*
+* `!GetAtt` accepts BOTH the scalar dot-delimited shape
+* (`!GetAtt LogicalId.Attribute.Path`) and the sequence shape
+* (`!GetAtt [LogicalId, Attribute]`); both round-trip back to the scalar
+* form when the attribute is a single string segment (the AWS-published
+* canonical shape), or to the sequence form when the attribute is itself
+* a sequence.
+*/
+/**
+* Tags whose long-form key uses the `Fn::` prefix. `!Ref`, `!Condition`,
+* and `!Transform` are special-cased separately because their long-form
+* key shape differs.
+*/
+const FN_TAGS = [
+	"GetAtt",
+	"Sub",
+	"Join",
+	"Select",
+	"Split",
+	"If",
+	"Equals",
+	"And",
+	"Or",
+	"Not",
+	"FindInMap",
+	"Base64",
+	"Cidr",
+	"GetAZs",
+	"ImportValue",
+	"Length",
+	"ToJsonString",
+	"ForEach"
+];
+function nodeJs(node) {
+	if (node === null || node === void 0) return null;
+	if (typeof node === "object" && node !== null && "toJSON" in node) return node.toJSON();
+	return node;
+}
+/**
+* Build the set of custom YAML tags cdkd registers. Each tag may need
+* up to 3 entries (scalar / seq / map) so every shape an AWS-published
+* template carries is accepted; un-templated shapes for a given tag
+* fall through to the lib's default tag resolution (which the lib
+* surfaces as a warning — never an error — by design).
+*
+* `identify: () => false` on every entry: we never want the lib to
+* auto-tag a parsed result on stringify. We build the YAML output via
+* our own `jsToYamlNode` walk that emits the tag explicitly.
+*/
+function buildCustomTags() {
+	const tags = [];
+	tags.push({
+		tag: "!Ref",
+		resolve(value) {
+			return { Ref: value };
+		},
+		identify: () => false
+	});
+	tags.push({
+		tag: "!Condition",
+		resolve(value) {
+			return { Condition: value };
+		},
+		identify: () => false
+	});
+	tags.push({
+		tag: "!Transform",
+		collection: "map",
+		resolve(node) {
+			return { "Fn::Transform": nodeJs(node) };
+		},
+		identify: () => false
+	});
+	tags.push({
+		tag: "!GetAtt",
+		resolve(value) {
+			const dot = value.indexOf(".");
+			if (dot < 0) throw new Error(`!GetAtt requires '<LogicalId>.<Attribute>'; got '${value}'`);
+			return { "Fn::GetAtt": [value.slice(0, dot), value.slice(dot + 1)] };
+		},
+		identify: () => false
+	});
+	tags.push({
+		tag: "!GetAtt",
+		collection: "seq",
+		resolve(node) {
+			return { "Fn::GetAtt": nodeJs(node) };
+		},
+		identify: () => false
+	});
+	for (const name of FN_TAGS) {
+		if (name === "GetAtt") continue;
+		const longKey = `Fn::${name}`;
+		tags.push({
+			tag: `!${name}`,
+			resolve(value) {
+				return { [longKey]: value };
+			},
+			identify: () => false
+		});
+		tags.push({
+			tag: `!${name}`,
+			collection: "seq",
+			resolve(node) {
+				return { [longKey]: nodeJs(node) };
+			},
+			identify: () => false
+		});
+		tags.push({
+			tag: `!${name}`,
+			collection: "map",
+			resolve(node) {
+				return { [longKey]: nodeJs(node) };
+			},
+			identify: () => false
+		});
+	}
+	return tags;
+}
+const CUSTOM_TAGS = buildCustomTags();
+/**
+* Parse a CFn template string. JSON or YAML, auto-detected.
+*
+* @throws Error with a clear message when the input is empty, malformed,
+*   or does not produce an object root.
+*/
+function parseCfnTemplate(text) {
+	const format = detectTemplateFormat(text);
+	const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	let parsed;
+	if (format === "json") try {
+		parsed = JSON.parse(body);
+	} catch (err) {
+		throw new Error(`Template is not valid JSON. Cause: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	else try {
+		parsed = parse$1(body, { customTags: CUSTOM_TAGS });
+	} catch (err) {
+		throw new Error(`Template is not valid YAML. Cause: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Template root is not an object.`);
+	return parsed;
+}
+/**
+* Serialize a CFn template back to JSON or YAML. The `format` parameter
+* controls the output shape; callers should pass the result of the
+* original `detectTemplateFormat` (or remembered from `parseCfnTemplate`)
+* so a YAML-authored template stays YAML on round-trip.
+*
+* YAML output emits CFn intrinsics back to shorthand tags (`!Ref`,
+* `!GetAtt`, etc.) by walking the JS object tree before passing it to
+* `yaml.stringify`. Long-form `{Fn::Foo: <args>}` objects are converted
+* to `Document` nodes carrying the appropriate `!Foo` tag.
+*
+* JSON output is two-space-indented to match cdkd's existing canonical
+* shape.
+*/
+function stringifyCfnTemplate(template, format) {
+	if (format === "json") return JSON.stringify(template, null, 2);
+	const doc = new Document();
+	doc.contents = jsToYamlNode(template, doc);
+	return stringify(doc, {
+		aliasDuplicateObjects: false,
+		lineWidth: 0
+	});
+}
+/**
+* Convert a plain JS value into a YAML node, detecting CFn intrinsics and
+* emitting them with their shorthand tag. Recursive — every sub-tree is
+* inspected.
+*/
+function jsToYamlNode(value, doc) {
+	if (value === null || value === void 0) return new Scalar(null);
+	if (typeof value !== "object") return doc.createNode(value);
+	if (Array.isArray(value)) {
+		const seq = new YAMLSeq();
+		for (const item of value) seq.items.push(jsToYamlNode(item, doc));
+		return seq;
+	}
+	const keys = Object.keys(value);
+	if (keys.length === 1) {
+		const k = keys[0];
+		const v = value[k];
+		const tag = intrinsicShorthandFor(k);
+		if (tag) return makeIntrinsicNode(tag, v, doc);
+	}
+	const map = new YAMLMap();
+	for (const [k, v] of Object.entries(value)) map.items.push(new Pair(doc.createNode(k), jsToYamlNode(v, doc)));
+	return map;
+}
+/**
+* Map a long-form intrinsic key (`Ref` / `Fn::Foo` / `Condition`) to its
+* shorthand tag (`!Ref` / `!Foo` / `!Condition`). Returns null when the
+* key is not a recognized intrinsic.
+*/
+function intrinsicShorthandFor(key) {
+	if (key === "Ref") return "!Ref";
+	if (key === "Condition") return "!Condition";
+	if (!key.startsWith("Fn::")) return null;
+	const name = key.slice(4);
+	if (name === "Transform") return "!Transform";
+	if (name === "GetAtt") return "!GetAtt";
+	if (FN_TAGS.includes(name)) return `!${name}`;
+	return null;
+}
+/**
+* Build a YAML node carrying a CFn shorthand tag. Tag-specific shapes:
+*   - `!Ref` / `!Condition` → scalar (the referenced name).
+*   - `!GetAtt` → scalar `LogicalId.Attribute` when the long-form arg
+*     is `[LogicalId, Attribute]` of strings; sequence form otherwise.
+*   - Everything else → whatever shape the long-form arg has
+*     (scalar / sequence / map).
+*/
+function makeIntrinsicNode(tag, value, doc) {
+	if (tag === "!Ref" || tag === "!Condition") {
+		const s = new Scalar(typeof value === "string" ? value : String(value));
+		s.tag = tag;
+		return s;
+	}
+	if (tag === "!GetAtt") {
+		if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "string") {
+			const s = new Scalar(`${value[0]}.${value[1]}`);
+			s.tag = tag;
+			return s;
+		}
+		const node = jsToYamlNode(value, doc);
+		node.tag = tag;
+		return node;
+	}
+	const node = jsToYamlNode(value, doc);
+	node.tag = tag;
+	return node;
+}
+/**
+* Sniff the input text and decide whether to parse it as JSON or YAML.
+*
+* Rule (matches AWS docs / CDK CLI): if the first non-whitespace byte is
+* `{` or `[`, parse as JSON; otherwise YAML. Empty input is treated as
+* JSON so the caller's existing JSON-empty-input error path fires.
+*
+* UTF-8 BOM (``) is stripped before the sniff — some editors /
+* scripts emit BOM-prefixed files, and the BOM is NOT whitespace under
+* `trimStart()`, so a BOM-prefixed JSON file would otherwise route to
+* the YAML parser and fail.
+*/
+function detectTemplateFormat(text) {
+	const trimmed = (text.charCodeAt(0) === 65279 ? text.slice(1) : text).trimStart();
+	if (trimmed.length === 0) return "json";
+	const first = trimmed.charCodeAt(0);
+	if (first === 123 || first === 91) return "json";
+	return "yaml";
+}
+/**
+* Parse a CFn template + return both the parsed object AND the source
+* format, so the caller can later re-emit in the same shape. Convenience
+* wrapper around `parseCfnTemplate` + `detectTemplateFormat`.
+*/
+function parseCfnTemplateWithFormat(text) {
+	const format = detectTemplateFormat(text);
+	return {
+		template: parseCfnTemplate(text),
+		format
+	};
+}
+
 //#endregion
 //#region src/cli/commands/retire-cfn-stack.ts
 /**
@@ -34823,7 +35125,7 @@ async function retireCloudFormationStack(options) {
 		TemplateStage: "Original"
 	}));
 	if (!tpl.TemplateBody) throw new Error(`GetTemplate returned no body for '${cfnStackName}'.`);
-	const { body: newBody, modified } = injectRetainPolicies(tpl.TemplateBody, cfnStackName);
+	const { body: newBody, modified, format } = injectRetainPolicies(tpl.TemplateBody, cfnStackName);
 	if (!yes) {
 		if (!await confirmPrompt$2(`Set DeletionPolicy=Retain and UpdateReplacePolicy=Retain on every resource in CloudFormation stack '${cfnStackName}', then delete the stack? AWS resources will NOT be deleted (cdkd state has been written).`)) {
 			logger.info("CloudFormation stack retirement cancelled. cdkd state is unaffected.");
@@ -34843,6 +35145,7 @@ async function retireCloudFormationStack(options) {
 				bucket: stateBucket,
 				body: newBody,
 				cfnStackName,
+				format,
 				...s3ClientOpts && { s3ClientOpts }
 			});
 			updateInput = { TemplateURL: uploaded.url };
@@ -34904,7 +35207,7 @@ async function retireCloudFormationStack(options) {
 * Exported for unit testing.
 */
 async function uploadTemplateForUpdateStack(args) {
-	const { bucket, body, cfnStackName, s3ClientOpts } = args;
+	const { bucket, body, cfnStackName, format, s3ClientOpts } = args;
 	const region = await resolveBucketRegion(bucket, {
 		...s3ClientOpts?.profile && { profile: s3ClientOpts.profile },
 		...s3ClientOpts?.credentials && { credentials: s3ClientOpts.credentials }
@@ -34914,13 +35217,15 @@ async function uploadTemplateForUpdateStack(args) {
 		...s3ClientOpts?.profile && { profile: s3ClientOpts.profile },
 		...s3ClientOpts?.credentials && { credentials: s3ClientOpts.credentials }
 	});
-	const key = `${MIGRATE_TMP_PREFIX}/${cfnStackName}/${Date.now()}.json`;
+	const ext = format === "yaml" ? "yaml" : "json";
+	const contentType = format === "yaml" ? "application/x-yaml" : "application/json";
+	const key = `${MIGRATE_TMP_PREFIX}/${cfnStackName}/${Date.now()}.${ext}`;
 	try {
 		await s3.send(new PutObjectCommand({
 			Bucket: bucket,
 			Key: key,
 			Body: body,
-			ContentType: "application/json"
+			ContentType: contentType
 		}));
 	} catch (err) {
 		s3.destroy();
@@ -34943,33 +35248,32 @@ async function uploadTemplateForUpdateStack(args) {
 	};
 }
 /**
-* Parse a CloudFormation template body (JSON), set `DeletionPolicy: Retain`
-* and `UpdateReplacePolicy: Retain` on every resource that doesn't already
-* have those exact values, and re-serialize.
+* Parse a CloudFormation template body (JSON or YAML), set
+* `DeletionPolicy: Retain` and `UpdateReplacePolicy: Retain` on every
+* resource that doesn't already have those exact values, and re-serialize
+* in the SAME format as the input. Returns the resulting body, a
+* `modified` flag, and the detected source format so callers can stamp
+* the right content type / S3 key extension on follow-up uploads.
 *
-* JSON-only by design. The `--migrate-from-cloudformation` flow's primary
-* upstream is `cdk migrate` (which produces a CDK app whose synthesized
-* template is always JSON) followed by `cdk deploy` / `cdkd deploy` (also
-* JSON). Adding YAML support would require parsing CloudFormation
-* shorthand intrinsics (`!Ref`, `!Sub`, `!GetAtt`, …) which round-trip
-* incorrectly through generic YAML libraries — a generic YAML
-* unmarshal/remarshal silently strips the custom tags and corrupts the
-* template. Until a CFn-aware YAML codec is in scope, hand-written YAML
-* stacks are best retired with the manual 3-step procedure.
+* YAML templates are routed through cdkd's CFn-aware YAML codec
+* (`src/cli/yaml-cfn.ts`), which preserves every CFn shorthand intrinsic
+* (`!Ref`, `!GetAtt`, `!Sub`, etc.) on round-trip. JSON templates take
+* the canonical two-space-indented JSON path.
 *
 * Exported for unit testing (the AWS round-trips are mocked, but the
 * mutation logic itself is pure and worth exercising directly).
 */
 function injectRetainPolicies(templateBody, cfnStackName) {
+	const format = detectTemplateFormat(templateBody);
 	let parsed;
 	try {
-		parsed = JSON.parse(templateBody);
+		parsed = parseCfnTemplate(templateBody);
 	} catch (err) {
-		throw new Error(`Template for '${cfnStackName}' is not valid JSON. cdkd's --migrate-from-cloudformation flow only supports CDK-generated (JSON) templates. Cause: ${err instanceof Error ? err.message : String(err)}`);
+		throw new Error(`Template for '${cfnStackName}' is not a valid CloudFormation template. cdkd's --migrate-from-cloudformation flow supports both JSON and YAML templates (YAML via a CFn-aware codec that preserves !Ref / !GetAtt / !Sub shorthand). Cause: ${err instanceof Error ? err.message : String(err)}`);
 	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("Resources" in parsed) || typeof parsed.Resources !== "object" || parsed.Resources === null) throw new Error(`Template for '${cfnStackName}' has no Resources section — refusing to retire.`);
+	if (!("Resources" in parsed) || typeof parsed["Resources"] !== "object" || parsed["Resources"] === null || Array.isArray(parsed["Resources"])) throw new Error(`Template for '${cfnStackName}' has no Resources section — refusing to retire.`);
 	let modified = false;
-	const resources = parsed.Resources;
+	const resources = parsed["Resources"];
 	for (const [, resource] of Object.entries(resources)) {
 		if (!resource || typeof resource !== "object" || Array.isArray(resource)) continue;
 		const r = resource;
@@ -34983,8 +35287,9 @@ function injectRetainPolicies(templateBody, cfnStackName) {
 		}
 	}
 	return {
-		body: JSON.stringify(parsed, null, 2),
-		modified
+		body: stringifyCfnTemplate(parsed, format),
+		modified,
+		format
 	};
 }
 /**
@@ -46128,10 +46433,13 @@ async function exportCommand(stackArg, options) {
 		let template;
 		let resolvedStackName;
 		let synthedRegion;
+		let templateFormat = "json";
 		let allSynthStacks = [];
 		if (options.template) {
 			if (!stackArg) throw new Error("--template requires a stack name as a positional argument to identify the cdkd state record.");
-			template = parseTemplateFile(options.template);
+			const parsed = parseTemplateFile(options.template);
+			template = parsed.template;
+			templateFormat = parsed.format;
 			resolvedStackName = stackArg;
 		} else {
 			const appCmd = options.app || resolveApp();
@@ -46228,7 +46536,7 @@ async function exportCommand(stackArg, options) {
 			const phase1Template = filterTemplateForImport(template, phase1Imports);
 			const injectedCount = injectDeletionPolicyForImport(phase1Template);
 			if (injectedCount > 0) logger.info(`Injected DeletionPolicy: Delete on ${injectedCount} resource(s) without an explicit DeletionPolicy (required by CFn IMPORT — matches the CDK/CFn default for resources without RemovalPolicy).`);
-			await executeImportChangeSet(awsClients.cloudFormation, cfnStackName, phase1Template, phase1Imports, cfnParameters);
+			await executeImportChangeSet(awsClients.cloudFormation, cfnStackName, phase1Template, phase1Imports, cfnParameters, templateFormat);
 			logger.info(`✓ Phase 1: CloudFormation stack '${cfnStackName}' created via IMPORT. ${phase1Imports.length} resource(s) imported.`);
 			if (recreateBeforePhase2.length > 0) for (const entry of recreateBeforePhase2) {
 				const handler = PRE_DELETE_HANDLERS[entry.resourceType];
@@ -46245,7 +46553,7 @@ async function exportCommand(stackArg, options) {
 			const phase2Count = phase2Creates.length + recreateBeforePhase2.length;
 			if (phase2Count > 0) try {
 				const phase2Template = applyImportOverlayForPhase2(template, phase1Imports);
-				await executeUpdateChangeSet(awsClients.cloudFormation, cfnStackName, phase2Template, cfnParameters);
+				await executeUpdateChangeSet(awsClients.cloudFormation, cfnStackName, phase2Template, cfnParameters, templateFormat);
 				const parts = [];
 				if (phase2Creates.length > 0) parts.push(`${phase2Creates.length} non-importable resource(s) CREATEd`);
 				if (recreateBeforePhase2.length > 0) parts.push(`${recreateBeforePhase2.length} IMPORT-unsupported resource(s) re-CREATEd`);
@@ -46305,14 +46613,15 @@ function parseTemplateFile(path) {
 	} catch (err) {
 		throw new Error(`Failed to read template file '${path}': ` + (err instanceof Error ? err.message : String(err)));
 	}
-	let parsed;
 	try {
-		parsed = JSON.parse(raw);
+		const { template, format } = parseCfnTemplateWithFormat(raw);
+		return {
+			template,
+			format
+		};
 	} catch (err) {
-		throw new Error(`Template file '${path}' is not valid JSON. cdkd export only supports JSON templates (CDK-generated). Cause: ` + (err instanceof Error ? err.message : String(err)));
+		throw new Error(`Template file '${path}' is not a valid CloudFormation template. cdkd export accepts JSON and YAML (YAML via a CFn-aware codec that preserves !Ref / !GetAtt / !Sub shorthand). Cause: ` + (err instanceof Error ? err.message : String(err)));
 	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Template file '${path}' is not a JSON object.`);
-	return parsed;
 }
 async function assertCfnStackAbsent(cfnClient, stackName) {
 	try {
@@ -46860,10 +47169,10 @@ function printPlan(plan, cfnStackName) {
 	}
 	logger.info("");
 }
-async function executeImportChangeSet(cfnClient, stackName, template, plan, parameters) {
+async function executeImportChangeSet(cfnClient, stackName, template, plan, parameters, templateFormat = "json") {
 	const logger = getLogger();
 	const changeSetName = `cdkd-migrate-${Date.now()}`;
-	const templateBody = JSON.stringify(template, null, 2);
+	const templateBody = stringifyCfnTemplate(template, templateFormat);
 	const resourcesToImport = plan.map((entry) => ({
 		ResourceType: entry.resourceType,
 		LogicalResourceId: entry.logicalId,
@@ -46974,10 +47283,10 @@ async function collectImportFailureSummary(cfnClient, stackName) {
 * (cdkd state is intentionally NOT deleted between phases, so a phase-2
 * failure leaves a recoverable state).
 */
-async function executeUpdateChangeSet(cfnClient, stackName, template, parameters) {
+async function executeUpdateChangeSet(cfnClient, stackName, template, parameters, templateFormat = "json") {
 	const logger = getLogger();
 	const changeSetName = `cdkd-phase2-${Date.now()}`;
-	const templateBody = JSON.stringify(template, null, 2);
+	const templateBody = stringifyCfnTemplate(template, templateFormat);
 	if (templateBody.length > 51200) throw new Error(`Full template is ${templateBody.length} bytes, over the 51,200-byte inline TemplateBody limit for phase-2 UPDATE. TemplateURL upload is not yet implemented.`);
 	logger.info(`Creating UPDATE changeset '${changeSetName}' for phase 2 (${templateBody.length} bytes)...`);
 	try {
@@ -47103,7 +47412,7 @@ async function confirmPrompt(prompt) {
 	}
 }
 function createExportCommand() {
-	const cmd = new Command("export").description("Hand a cdkd-managed stack over to CloudFormation via CFn IMPORT (changeset). AWS resources are unchanged; cdkd state for the stack is deleted on success. Mirror of `cdkd import` (AWS → cdkd) in the reverse direction (cdkd → CFn). JSON templates only. Aborts if any resource is not CFn-importable.").argument("[stack]", "Stack name to export (auto-detected for single-stack apps)").option("--cfn-stack-name <name>", "Name of the destination CloudFormation stack. Defaults to the cdkd stack name.").option("--template <path>", "Path to a pre-rendered CloudFormation template (JSON). Skips synth.").option("--stack-region <region>", "Region of the cdkd state record to operate on. Required when the same stack name has state in multiple regions.").option("--dry-run", "Print the import plan without creating a changeset.", false).option("--accept-transient-context", "Allow CLI -c key=value overrides at export time even though they are not persisted to cdk.json / cdk.context.json (default: refuse). When set, the user is responsible for passing the same -c flags to every future cdk deploy.", false).option("--include-non-importable", "Run a 2-phase migration when the stack contains non-importable resources (Custom::*). Phase 1 imports the importable resources; phase 2 CFn-CREATEs the non-importable ones, which re-invokes each Custom Resource's onCreate handler. Make sure onCreate is idempotent before enabling.", false).option("--parameter <key=value...>", "CFn template Parameter override, repeatable. Required when the synthesized template has Parameters without Default values; otherwise overrides the template's default value. Format: --parameter Key=Value.").option("--strict-cross-stack", "Refuse to export when sibling cdkd stacks in the same CDK app reference the exporting stack via Fn::GetStackOutput. Without the flag, cdkd warns but proceeds — the user is expected to migrate the consumer stacks in a follow-up.", false).option("--no-recreate-import-unsupported", "Block instead of auto-handling resource types AWS does NOT support in IMPORT changesets (currently only AWS::ApiGatewayV2::Stage, emitted by CDK HttpApi). Default behavior: cdkd skips these from phase 1, deletes the AWS-side resource between phases, and lets CFn re-CREATE in phase 2 (brief unavailability window). With this flag, the export aborts with a clear error instead.").action(withErrorHandling(exportCommand));
+	const cmd = new Command("export").description("Hand a cdkd-managed stack over to CloudFormation via CFn IMPORT (changeset). AWS resources are unchanged; cdkd state for the stack is deleted on success. Mirror of `cdkd import` (AWS → cdkd) in the reverse direction (cdkd → CFn). Accepts JSON and YAML templates (YAML via a CFn-aware codec that preserves !Ref / !GetAtt / !Sub shorthand). Aborts if any resource is not CFn-importable.").argument("[stack]", "Stack name to export (auto-detected for single-stack apps)").option("--cfn-stack-name <name>", "Name of the destination CloudFormation stack. Defaults to the cdkd stack name.").option("--template <path>", "Path to a pre-rendered CloudFormation template (JSON or YAML — format auto-detected). Skips synth.").option("--stack-region <region>", "Region of the cdkd state record to operate on. Required when the same stack name has state in multiple regions.").option("--dry-run", "Print the import plan without creating a changeset.", false).option("--accept-transient-context", "Allow CLI -c key=value overrides at export time even though they are not persisted to cdk.json / cdk.context.json (default: refuse). When set, the user is responsible for passing the same -c flags to every future cdk deploy.", false).option("--include-non-importable", "Run a 2-phase migration when the stack contains non-importable resources (Custom::*). Phase 1 imports the importable resources; phase 2 CFn-CREATEs the non-importable ones, which re-invokes each Custom Resource's onCreate handler. Make sure onCreate is idempotent before enabling.", false).option("--parameter <key=value...>", "CFn template Parameter override, repeatable. Required when the synthesized template has Parameters without Default values; otherwise overrides the template's default value. Format: --parameter Key=Value.").option("--strict-cross-stack", "Refuse to export when sibling cdkd stacks in the same CDK app reference the exporting stack via Fn::GetStackOutput. Without the flag, cdkd warns but proceeds — the user is expected to migrate the consumer stacks in a follow-up.", false).option("--no-recreate-import-unsupported", "Block instead of auto-handling resource types AWS does NOT support in IMPORT changesets (currently only AWS::ApiGatewayV2::Stage, emitted by CDK HttpApi). Default behavior: cdkd skips these from phase 1, deletes the AWS-side resource between phases, and lets CFn re-CREATE in phase 2 (brief unavailability window). With this flag, the export aborts with a clear error instead.").action(withErrorHandling(exportCommand));
 	[
 		...commonOptions,
 		...appOptions,
@@ -47155,7 +47464,7 @@ function reorderArgs(argv) {
 */
 async function main() {
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.123.0");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.124.0");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());