@fuzdev/fuz_ui 0.181.1 → 0.182.0

package/src/lib/svelte_preprocess_mdz.ts

@@ -0,0 +1,726 @@
+/**
+ * Svelte preprocessor that compiles static `Mdz` content to Svelte markup at build time.
+ *
+ * Detects `Mdz` components with static string `content` props, parses the mdz content,
+ * renders each `MdzNode` to equivalent Svelte markup via `mdz_to_svelte`, and replaces
+ * the `Mdz` with `MdzPrecompiled` containing pre-rendered children.
+ *
+ * Also handles ternary chains (`content={a ? 'x' : b ? 'y' : 'z'}`) where all leaf
+ * values are statically resolvable strings, emitting `{#if a}markup_x{:else if b}markup_y{:else}markup_z{/if}`
+ * as children of a single `MdzPrecompiled`.
+ *
+ * Truly dynamic `content` props are left untouched.
+ *
+ * @module
+ */
+
+import type {ImportDeclaration, VariableDeclaration} from 'estree';
+import {parse, type PreprocessorGroup, type AST} from 'svelte/compiler';
+import MagicString from 'magic-string';
+import {walk} from 'zimmerframe';
+import {should_exclude_path} from '@fuzdev/fuz_util/path.js';
+import {
+	find_attribute,
+	extract_static_string,
+	try_extract_conditional_chain,
+	build_static_bindings,
+	resolve_component_names,
+	has_identifier_in_tree,
+	find_import_insert_position,
+	generate_import_lines,
+	remove_variable_declaration,
+	remove_import_declaration,
+	remove_import_specifier,
+	handle_preprocess_error,
+	type PreprocessImportInfo,
+	type ResolvedComponentImport,
+} from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
+
+import {mdz_parse} from './mdz.js';
+import {mdz_to_svelte} from './mdz_to_svelte.js';
+
+/**
+ * An estree `ImportDeclaration` augmented with Svelte's position data.
+ * Svelte's parser adds `start`/`end` to all AST nodes, but the estree
+ * types don't declare them.
+ */
+type PositionedImportDeclaration = ImportDeclaration & AST.BaseNode;
+
+/**
+ * Options for `svelte_preprocess_mdz`.
+ */
+export interface SveltePreprocessMdzOptions {
+	/** File patterns to exclude. */
+	exclude?: Array<string | RegExp>;
+
+	/**
+	 * Component import mapping for mdz content.
+	 * Key: component name as used in mdz (e.g., 'Alert').
+	 * Value: import path (e.g., '$lib/Alert.svelte').
+	 *
+	 * If mdz content references a component not in this map,
+	 * that Mdz usage is skipped (left as runtime).
+	 */
+	components?: Record<string, string>;
+
+	/**
+	 * Allowed HTML elements in mdz content.
+	 * If mdz content references an element not in this list,
+	 * that Mdz usage is skipped (left as runtime).
+	 */
+	elements?: Array<string>;
+
+	/**
+	 * Import sources that resolve to the Mdz component.
+	 * Used to verify that `Mdz` in templates refers to fuz_ui's Mdz.svelte.
+	 *
+	 * @default ['@fuzdev/fuz_ui/Mdz.svelte']
+	 */
+	component_imports?: Array<string>;
+
+	/**
+	 * Import path for the precompiled wrapper component.
+	 *
+	 * @default '@fuzdev/fuz_ui/MdzPrecompiled.svelte'
+	 */
+	compiled_component_import?: string;
+
+	/**
+	 * How to handle errors during mdz parsing or rendering.
+	 *
+	 * @default 'throw' in CI, 'log' otherwise
+	 */
+	on_error?: 'log' | 'throw';
+}
+
+const PRECOMPILED_NAME = 'MdzPrecompiled';
+
+/**
+ * Creates a Svelte preprocessor that compiles static `Mdz` content at build time.
+ *
+ * @param options Configuration for component/element resolution and file filtering.
+ * @returns A Svelte `PreprocessorGroup` for use in `svelte.config.js`.
+ */
+export const svelte_preprocess_mdz = (
+	options: SveltePreprocessMdzOptions = {},
+): PreprocessorGroup => {
+	const {
+		exclude = [],
+		components = {},
+		elements: elements_array = [],
+		component_imports = ['@fuzdev/fuz_ui/Mdz.svelte'],
+		compiled_component_import = '@fuzdev/fuz_ui/MdzPrecompiled.svelte',
+		on_error = process.env.CI === 'true' ? 'throw' : 'log',
+	} = options;
+	const elements = new Set(elements_array);
+
+	return {
+		name: 'fuz-mdz',
+
+		markup: ({content, filename}) => {
+			if (should_exclude_path(filename, exclude)) {
+				return {code: content};
+			}
+
+			// Quick bail: does file mention any known Mdz import source?
+			if (!component_imports.some((source) => content.includes(source))) {
+				return {code: content};
+			}
+
+			const ast = parse(content, {filename, modern: true});
+
+			// Resolve which local names map to the Mdz component
+			const mdz_names = resolve_component_names(ast, component_imports);
+			if (mdz_names.size === 0) {
+				return {code: content};
+			}
+
+			// Check for MdzPrecompiled name collision
+			if (has_name_collision(ast, compiled_component_import)) {
+				return {code: content};
+			}
+
+			const s = new MagicString(content);
+			const bindings = build_static_bindings(ast);
+
+			// Find and transform Mdz usages with static content
+			const {transformations, total_usages, transformed_usages} = find_mdz_usages(ast, mdz_names, {
+				components,
+				elements,
+				filename,
+				source: content,
+				bindings,
+				on_error,
+			});
+
+			if (transformations.length === 0) {
+				return {code: content};
+			}
+
+			// Apply transformations
+			for (const t of transformations) {
+				s.overwrite(t.start, t.end, t.replacement);
+			}
+
+			// Remove dead const bindings that were consumed by transformations
+			remove_dead_const_bindings(s, ast, transformations, content);
+
+			// Determine which Mdz imports can be removed
+			const removable_imports = find_removable_mdz_imports(
+				ast,
+				mdz_names,
+				total_usages,
+				transformed_usages,
+			);
+
+			// Add required imports and remove unused Mdz imports
+			manage_imports(
+				s,
+				ast,
+				transformations,
+				removable_imports,
+				compiled_component_import,
+				content,
+			);
+
+			return {
+				code: s.toString(),
+				map: s.generateMap({hires: true}),
+			};
+		},
+	};
+};
+
+interface MdzTransformation {
+	start: number;
+	end: number;
+	replacement: string;
+	required_imports: Map<string, PreprocessImportInfo>;
+	/** Const binding names that were resolved to produce this transformation. */
+	consumed_bindings: Set<string>;
+	/** The original AST component node, used to skip during dead code analysis. */
+	component_node: AST.Component;
+}
+
+interface FindMdzUsagesResult {
+	transformations: Array<MdzTransformation>;
+	/** Total template usages per Mdz local name. */
+	total_usages: Map<string, number>;
+	/** Successfully transformed usages per Mdz local name. */
+	transformed_usages: Map<string, number>;
+}
+
+interface FindMdzUsagesContext {
+	components: Record<string, string>;
+	elements: ReadonlySet<string>;
+	filename: string | undefined;
+	source: string;
+	bindings: ReadonlyMap<string, string>;
+	on_error: 'log' | 'throw';
+}
+
+/**
+ * Checks if `MdzPrecompiled` is already imported from a different source.
+ * If so, the preprocessor bails to avoid name collisions.
+ */
+const has_name_collision = (ast: AST.Root, compiled_component_import: string): boolean => {
+	for (const script of [ast.instance, ast.module]) {
+		if (!script) continue;
+		for (const node of script.content.body) {
+			if (node.type !== 'ImportDeclaration') continue;
+			const source_path = node.source.value as string;
+			for (const spec of node.specifiers) {
+				if (spec.local.name === PRECOMPILED_NAME && source_path !== compiled_component_import) {
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+};
+
+/**
+ * Collects identifiers from an expression that resolved through bindings.
+ * Only collects top-level Identifier nodes that appear in the bindings map.
+ *
+ * TODO: support transitive dead const removal — currently only directly-consumed
+ * bindings (identifiers in the expression AST) are tracked. Transitive dependencies
+ * (e.g., `const a = 'x'; const b = a; content={b}` — `a` is not removed) are not
+ * traced. After removing a dead const, re-check whether identifiers in its
+ * initializer became dead too.
+ */
+const collect_consumed_bindings = (
+	value: AST.Attribute['value'],
+	bindings: ReadonlyMap<string, string>,
+): Set<string> => {
+	const consumed: Set<string> = new Set();
+	if (value === true || Array.isArray(value)) return consumed;
+	const collect_from_expr = (expr: {type: string; [key: string]: any}): void => {
+		if (expr.type === 'Identifier' && bindings.has(expr.name)) {
+			consumed.add(expr.name);
+		} else if (expr.type === 'BinaryExpression' && expr.operator === '+') {
+			collect_from_expr(expr.left);
+			collect_from_expr(expr.right);
+		} else if (expr.type === 'TemplateLiteral') {
+			for (const e of expr.expressions) {
+				collect_from_expr(e);
+			}
+		} else if (expr.type === 'ConditionalExpression') {
+			collect_from_expr(expr.consequent);
+			collect_from_expr(expr.alternate);
+		}
+	};
+	collect_from_expr(value.expression);
+	return consumed;
+};
+
+/**
+ * Walks the AST to find `Mdz` component usages with static `content` props
+ * and generates transformations to replace them with `MdzPrecompiled` children.
+ */
+const find_mdz_usages = (
+	ast: AST.Root,
+	mdz_names: Map<string, ResolvedComponentImport>,
+	context: FindMdzUsagesContext,
+): FindMdzUsagesResult => {
+	const transformations: Array<MdzTransformation> = [];
+	const total_usages: Map<string, number> = new Map();
+	const transformed_usages: Map<string, number> = new Map();
+
+	// zimmerframe types visitors against {type: string}, requiring explicit annotations
+	// on the callback parameters for Svelte-specific AST types like AST.Component
+	walk(ast.fragment as any, null, {
+		Component(node: AST.Component, ctx: {next: () => void}) {
+			// Always recurse into children so nested Mdz components are found
+			ctx.next();
+
+			if (!mdz_names.has(node.name)) return;
+
+			// Track total usages per name
+			total_usages.set(node.name, (total_usages.get(node.name) ?? 0) + 1);
+
+			// Skip if spread attributes present — can't determine content statically
+			if (node.attributes.some((attr) => attr.type === 'SpreadAttribute')) return;
+
+			const content_attr = find_attribute(node, 'content');
+			if (!content_attr) return;
+
+			// Extract static string value
+			const content_value = extract_static_string(content_attr.value, context.bindings);
+			if (content_value !== null) {
+				// Parse mdz content and render to Svelte markup
+				let result;
+				try {
+					const nodes = mdz_parse(content_value);
+					result = mdz_to_svelte(nodes, context.components, context.elements);
+				} catch (error) {
+					handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
+					return;
+				}
+
+				// If content has unconfigured tags, skip this usage (fall back to runtime)
+				if (result.has_unconfigured_tags) return;
+
+				const consumed = collect_consumed_bindings(content_attr.value, context.bindings);
+				const replacement = build_replacement(node, content_attr, result.markup, context.source);
+				transformed_usages.set(node.name, (transformed_usages.get(node.name) ?? 0) + 1);
+				transformations.push({
+					start: node.start,
+					end: node.end,
+					replacement,
+					required_imports: result.imports,
+					consumed_bindings: consumed,
+					component_node: node,
+				});
+				return;
+			}
+
+			// Try conditional chain (handles both simple and nested ternaries)
+			const chain = try_extract_conditional_chain(
+				content_attr.value,
+				context.source,
+				context.bindings,
+			);
+			if (chain === null) return;
+
+			// Parse and render each branch
+			const branch_results: Array<{markup: string; imports: Map<string, PreprocessImportInfo>}> =
+				[];
+			try {
+				for (const branch of chain) {
+					const nodes = mdz_parse(branch.value);
+					const result = mdz_to_svelte(nodes, context.components, context.elements);
+					if (result.has_unconfigured_tags) return;
+					branch_results.push({markup: result.markup, imports: result.imports});
+				}
+			} catch (error) {
+				handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
+				return;
+			}
+
+			// Build {#if}/{:else if}/{:else} markup
+			let children_markup = '';
+			for (let i = 0; i < chain.length; i++) {
+				const branch = chain[i]!;
+				const result = branch_results[i]!;
+				if (i === 0) {
+					children_markup += `{#if ${branch.test_source}}${result.markup}`;
+				} else if (branch.test_source !== null) {
+					children_markup += `{:else if ${branch.test_source}}${result.markup}`;
+				} else {
+					children_markup += `{:else}${result.markup}`;
+				}
+			}
+			children_markup += '{/if}';
+
+			const replacement = build_replacement(node, content_attr, children_markup, context.source);
+
+			// Merge imports from all branches
+			const merged_imports: Map<string, PreprocessImportInfo> = new Map();
+			for (const result of branch_results) {
+				for (const [name, info] of result.imports) {
+					merged_imports.set(name, info);
+				}
+			}
+
+			const consumed = collect_consumed_bindings(content_attr.value, context.bindings);
+			transformed_usages.set(node.name, (transformed_usages.get(node.name) ?? 0) + 1);
+			transformations.push({
+				start: node.start,
+				end: node.end,
+				replacement,
+				required_imports: merged_imports,
+				consumed_bindings: consumed,
+				component_node: node,
+			});
+		},
+	});
+
+	return {transformations, total_usages, transformed_usages};
+};
+
+/**
+ * Removes dead `const` bindings from the instance script that were consumed
+ * by transformations and are no longer referenced anywhere else in the file.
+ *
+ * Only handles single-declarator `const` statements. Skips `const a = 'x', b = 'y'`
+ * and module script variables (which could be exported/imported by other files).
+ */
+const remove_dead_const_bindings = (
+	s: MagicString,
+	ast: AST.Root,
+	transformations: Array<MdzTransformation>,
+	source: string,
+): void => {
+	// Collect all consumed binding names across transformations
+	const all_consumed: Set<string> = new Set();
+	for (const t of transformations) {
+		for (const name of t.consumed_bindings) {
+			all_consumed.add(name);
+		}
+	}
+	if (all_consumed.size === 0) return;
+
+	// Only remove from instance script (module script variables could be exported)
+	const instance = ast.instance;
+	if (!instance) return;
+
+	// Build a skip set of transformed component nodes so their attribute
+	// expressions (which still contain the old identifiers) don't false-match
+	const skip: Set<unknown> = new Set();
+	for (const t of transformations) {
+		skip.add(t.component_node);
+	}
+
+	for (const name of all_consumed) {
+		// Find the VariableDeclaration containing this binding in instance script
+		let declaration_node: (VariableDeclaration & {start: number; end: number}) | null = null;
+		for (const node of instance.content.body) {
+			if (node.type !== 'VariableDeclaration' || node.kind !== 'const') continue;
+			for (const decl of node.declarations) {
+				if (decl.id.type === 'Identifier' && decl.id.name === name) {
+					declaration_node = node as VariableDeclaration & {start: number; end: number};
+					break;
+				}
+			}
+			if (declaration_node) break;
+		}
+
+		if (!declaration_node) continue;
+
+		// Only handle single-declarator statements
+		if (declaration_node.declarations.length !== 1) continue;
+
+		// Check if the identifier is referenced anywhere else
+		const id_skip = new Set([...skip, declaration_node]);
+
+		// Check instance script (excluding the declaration itself)
+		if (has_identifier_in_tree(instance.content, name, id_skip)) continue;
+
+		// Check module script
+		if (ast.module?.content && has_identifier_in_tree(ast.module.content, name)) continue;
+
+		// Check template — skip transformed component nodes whose attribute expressions
+		// still contain the old identifier references in the AST
+		if (has_identifier_in_tree(ast.fragment, name, id_skip)) continue;
+
+		remove_variable_declaration(s, declaration_node, source);
+		// Add to skip set so chained dead const checks don't find references to this removed node
+		skip.add(declaration_node);
+	}
+};
+
+/**
+ * Builds the replacement string for a transformed Mdz component.
+ *
+ * Reconstructs the opening tag as `<MdzPrecompiled` with all attributes except `content`,
+ * using source text slicing to preserve exact formatting and dynamic expressions.
+ */
+const build_replacement = (
+	node: AST.Component,
+	content_attr: AST.Attribute,
+	children_markup: string,
+	source: string,
+): string => {
+	// Collect source ranges of all attributes EXCEPT content
+	const other_attr_ranges: Array<{start: number; end: number}> = [];
+	for (const attr of node.attributes) {
+		if (attr === content_attr) continue;
+		other_attr_ranges.push({start: attr.start, end: attr.end});
+	}
+
+	// Build opening tag with MdzPrecompiled name
+	let opening = `<${PRECOMPILED_NAME}`;
+	for (const range of other_attr_ranges) {
+		opening += ' ' + source.slice(range.start, range.end);
+	}
+	opening += '>';
+
+	return `${opening}${children_markup}</${PRECOMPILED_NAME}>`;
+};
+
+/** Result of import removability analysis for a single Mdz name. */
+interface ImportRemovalAction {
+	/** The import declaration node. */
+	node: PositionedImportDeclaration;
+	/** 'full' removes the entire declaration; 'partial' removes only the Mdz specifier. */
+	kind: 'full' | 'partial';
+	/** For partial removal: the specifier to remove. */
+	specifier_to_remove?: ImportDeclaration['specifiers'][number];
+}
+
+/**
+ * Determines which Mdz import declarations can be safely removed or trimmed.
+ *
+ * An import is removable when:
+ * 1. All template usages of that name were successfully transformed.
+ * 2. The identifier is not referenced elsewhere in script or template expressions.
+ *
+ * For multi-specifier imports, only the Mdz specifier is removed (partial removal).
+ * For single-specifier imports, the entire declaration is removed.
+ */
+const find_removable_mdz_imports = (
+	ast: AST.Root,
+	mdz_names: Map<string, ResolvedComponentImport>,
+	total_usages: Map<string, number>,
+	transformed_usages: Map<string, number>,
+): Map<string, ImportRemovalAction> => {
+	const removable: Map<string, ImportRemovalAction> = new Map();
+
+	for (const [name, {import_node, specifier}] of mdz_names) {
+		const total = total_usages.get(name) ?? 0;
+		const transformed = transformed_usages.get(name) ?? 0;
+
+		// Only remove if ALL template usages were transformed
+		if (total === 0 || transformed < total) continue;
+
+		// Check if identifier is referenced elsewhere in the AST
+		const skip: Set<unknown> = new Set([import_node]);
+
+		// Check instance script body (excluding the import itself)
+		if (ast.instance?.content && has_identifier_in_tree(ast.instance.content, name, skip)) {
+			continue;
+		}
+
+		// Check module script body (excluding the import itself)
+		if (ast.module?.content && has_identifier_in_tree(ast.module.content, name, skip)) {
+			continue;
+		}
+
+		// Check template for expression references (Component.name is a string, not Identifier)
+		if (has_identifier_in_tree(ast.fragment, name)) {
+			continue;
+		}
+
+		const positioned_node = import_node as PositionedImportDeclaration;
+		if (import_node.specifiers.length === 1) {
+			removable.set(name, {node: positioned_node, kind: 'full'});
+		} else {
+			removable.set(name, {
+				node: positioned_node,
+				kind: 'partial',
+				specifier_to_remove: specifier,
+			});
+		}
+	}
+
+	return removable;
+};
+
+/**
+ * Manages import additions and removals.
+ *
+ * Adds the `MdzPrecompiled` import and other required imports (DocsLink, Code, resolve).
+ * Removes Mdz import declarations that are no longer referenced.
+ *
+ * Handles both full removal (single-specifier imports) and partial removal
+ * (multi-specifier imports where only the Mdz specifier is removed).
+ *
+ * To avoid MagicString boundary conflicts when the insertion position falls inside
+ * a removal range, one removable Mdz import is overwritten with the MdzPrecompiled
+ * import line instead of using separate remove + appendLeft.
+ */
+const manage_imports = (
+	s: MagicString,
+	ast: AST.Root,
+	transformations: Array<MdzTransformation>,
+	removable_imports: Map<string, ImportRemovalAction>,
+	compiled_component_import: string,
+	source: string,
+): void => {
+	// Collect all required imports across transformations
+	const required: Map<string, PreprocessImportInfo> = new Map();
+	for (const t of transformations) {
+		for (const [name, info] of t.required_imports) {
+			required.set(name, info);
+		}
+	}
+
+	// Always need MdzPrecompiled when transformations occur
+	required.set(PRECOMPILED_NAME, {path: compiled_component_import, kind: 'default'});
+
+	const script = ast.instance;
+
+	// Separate full removals from partial removals
+	const full_removals: Set<PositionedImportDeclaration> = new Set();
+	const partial_removals: Array<ImportRemovalAction> = [];
+	for (const [, action] of removable_imports) {
+		if (action.kind === 'full') {
+			full_removals.add(action.node);
+		} else {
+			partial_removals.push(action);
+		}
+	}
+
+	if (!script) {
+		// No instance script — removable_imports won't apply (imports are in module script if any)
+		// Just add all required imports
+		const lines = generate_import_lines(required);
+		if (ast.module) {
+			s.appendLeft(ast.module.end, `\n\n<script lang="ts">\n${lines}\n</script>`);
+		} else {
+			s.prepend(`<script lang="ts">\n${lines}\n</script>\n\n`);
+		}
+		// Remove Mdz imports from module script if removable
+		for (const node of full_removals) {
+			remove_import_declaration(s, node, source);
+		}
+		// Apply partial removals
+		for (const action of partial_removals) {
+			remove_import_specifier(s, action.node, action.specifier_to_remove!, source);
+		}
+		return;
+	}
+
+	// Check existing imports to avoid duplicates — tracks both name AND source path
+	const existing: Map<string, string> = new Map();
+	for (const node of script.content.body) {
+		if (node.type === 'ImportDeclaration') {
+			const source_path = node.source.value as string;
+			for (const spec of node.specifiers) {
+				existing.set(spec.local.name, source_path);
+			}
+		}
+	}
+
+	const to_add: Map<string, PreprocessImportInfo> = new Map();
+	for (const [name, info] of required) {
+		const existing_path = existing.get(name);
+		if (existing_path === undefined) {
+			to_add.set(name, info);
+		}
+	}
+
+	// Strategy: if we're both adding MdzPrecompiled and removing an Mdz import,
+	// overwrite one full-removable import with the MdzPrecompiled line to avoid
+	// MagicString boundary conflicts. Other imports use normal appendLeft.
+	let overwrite_target: PositionedImportDeclaration | null = null;
+	if (to_add.has(PRECOMPILED_NAME) && full_removals.size > 0) {
+		// Pick the first removable import to overwrite
+		overwrite_target = full_removals.values().next().value ?? null;
+	}
+
+	// Generate the MdzPrecompiled import line separately if using overwrite
+	if (overwrite_target) {
+		const node_start = overwrite_target.start;
+		const node_end = overwrite_target.end;
+
+		// Find the start of the line (consume leading whitespace)
+		let line_start = node_start;
+		while (line_start > 0 && (source[line_start - 1] === '\t' || source[line_start - 1] === ' ')) {
+			line_start--;
+		}
+
+		// Extract indentation from the original import line rather than hardcoding a tab.
+		// The import node's start is after any leading whitespace, so the indentation is
+		// the characters between the line start and the node start.
+		const original_indent = source.slice(line_start, node_start);
+		const precompiled_line = `${original_indent}import ${PRECOMPILED_NAME} from '${compiled_component_import}';`;
+
+		s.overwrite(line_start, node_end, precompiled_line);
+		to_add.delete(PRECOMPILED_NAME);
+	}
+
+	// When there are partial removals but no full-removal overwrite target,
+	// the appendLeft at find_import_insert_position can conflict with the
+	// partial removal's overwrite (they share the same node.end boundary).
+	// Bundle the new imports into the first partial removal's overwrite instead.
+	const insert_pos = find_import_insert_position(script);
+	let partial_carrier: ImportRemovalAction | null = null;
+	if (to_add.size > 0 && partial_removals.length > 0) {
+		for (const action of partial_removals) {
+			if (action.node.end === insert_pos) {
+				partial_carrier = action;
+				break;
+			}
+		}
+	}
+
+	// Add remaining imports — either bundled with a partial removal or via appendLeft
+	let carrier_lines = '';
+	if (partial_carrier && to_add.size > 0) {
+		carrier_lines = '\n' + generate_import_lines(to_add);
+		to_add.clear();
+	}
+	if (to_add.size > 0) {
+		const lines = generate_import_lines(to_add);
+		s.appendLeft(insert_pos, '\n' + lines);
+	}
+
+	// Remove remaining full Mdz imports (skip the overwrite target)
+	for (const node of full_removals) {
+		if (node === overwrite_target) continue;
+		remove_import_declaration(s, node, source);
+	}
+
+	// Apply partial import removals
+	for (const action of partial_removals) {
+		remove_import_specifier(
+			s,
+			action.node,
+			action.specifier_to_remove!,
+			source,
+			action === partial_carrier ? carrier_lines : '',
+		);
+	}
+};