@abapify/ts-xsd 0.4.34 → 0.4.38

package/dist/{runner-BGNA8Sl-.mjs → runner-BZNOc_YZ.mjs}

@@ -15,10 +15,7 @@ function isElement(node) {
 */
 function getAttributeValue(node, name) {
 	if (node.hasAttribute(name)) return node.getAttribute(name);
-	for (let i = 0; i < node.attributes.length; i++) {
-		const attr = node.attributes[i];
-		if ((attr.localName || attr.name.split(":").pop()) === name) return attr.value;
-	}
+	for (const attr of node.attributes) if ((attr.localName || attr.name.split(":").pop()) === name) return attr.value;
 	return null;
 }
 /**
@@ -26,11 +23,8 @@ function getAttributeValue(node, name) {
 */
 function getChildElements(parent, name) {
 	const result = [];
-	for (let i = 0; i < parent.childNodes.length; i++) {
-		const child = parent.childNodes[i];
-		if (isElement(child)) {
-			if ((child.localName || child.tagName.split(":").pop()) === name) result.push(child);
-		}
+	for (const child of parent.childNodes) if (isElement(child)) {
+		if ((child.localName || child.tagName.split(":").pop()) === name) result.push(child);
 	}
 	return result;
 }
@@ -39,10 +33,7 @@ function getChildElements(parent, name) {
 */
 function getAllChildElements(parent) {
 	const result = [];
-	for (let i = 0; i < parent.childNodes.length; i++) {
-		const child = parent.childNodes[i];
-		if (isElement(child)) result.push(child);
-	}
+	for (const child of parent.childNodes) if (isElement(child)) result.push(child);
 	return result;
 }
 /**
@@ -50,10 +41,7 @@ function getAllChildElements(parent) {
 */
 function getTextContent(node) {
 	let text = "";
-	for (let i = 0; i < node.childNodes.length; i++) {
-		const child = node.childNodes[i];
-		if (child.nodeType === 3) text += child.textContent || "";
-	}
+	for (const child of node.childNodes) if (child.nodeType === 3) text += child.textContent || "";
 	return text.trim();
 }
 /**
@@ -827,8 +815,7 @@ function parseAnnotationChild(el, result) {
 function extractXmlns(el) {
 	const xmlns = {};
 	let hasXmlns = false;
-	for (let i = 0; i < el.attributes.length; i++) {
-		const attr = el.attributes[i];
+	for (const attr of el.attributes) {
 		const name = attr.name;
 		const value = attr.value;
 		if (name === "xmlns") {
@@ -924,12 +911,12 @@ var SchemaTraverser = class {
 		this.onLeaveSchema(schema);
 	}
 	traverseSchemaChildren(schema) {
-		if (schema.complexType) for (const ct of schema.complexType) this.onComplexType(ct);
-		if (schema.simpleType) for (const st of schema.simpleType) this.onSimpleType(st);
-		if (schema.element) for (const element of schema.element) this.onElement(element);
-		if (schema.attribute) for (const attr of schema.attribute) this.onAttribute(attr);
-		if (schema.group) for (const group of schema.group) this.onGroup(group);
-		if (schema.attributeGroup) for (const group of schema.attributeGroup) this.onAttributeGroup(group);
+		for (const ct of schema.complexType ?? []) this.onComplexType(ct);
+		for (const st of schema.simpleType ?? []) this.onSimpleType(st);
+		for (const element of schema.element ?? []) this.onElement(element);
+		for (const attr of schema.attribute ?? []) this.onAttribute(attr);
+		for (const group of schema.group ?? []) this.onGroup(group);
+		for (const group of schema.attributeGroup ?? []) this.onAttributeGroup(group);
 	}
 	traverseRedefines(schema) {
 		if (!schema.redefine) return;
@@ -937,28 +924,34 @@ var SchemaTraverser = class {
 		this.source = "redefine";
 		for (const redefine of schema.redefine) {
 			this.onRedefine(redefine);
-			if (redefine.complexType) for (const ct of redefine.complexType) this.onComplexType(ct);
-			if (redefine.simpleType) for (const st of redefine.simpleType) this.onSimpleType(st);
-			if (redefine.group) for (const group of redefine.group) this.onGroup(group);
-			if (redefine.attributeGroup) for (const group of redefine.attributeGroup) this.onAttributeGroup(group);
+			this.traverseRedefineChildren(redefine);
 		}
 		this.source = prevSource;
 	}
+	traverseRedefineChildren(redefine) {
+		for (const ct of redefine.complexType ?? []) this.onComplexType(ct);
+		for (const st of redefine.simpleType ?? []) this.onSimpleType(st);
+		for (const group of redefine.group ?? []) this.onGroup(group);
+		for (const group of redefine.attributeGroup ?? []) this.onAttributeGroup(group);
+	}
 	traverseOverrides(schema) {
 		if (!schema.override) return;
 		const prevSource = this.source;
 		this.source = "override";
 		for (const override of schema.override) {
 			this.onOverride(override);
-			if (override.complexType) for (const ct of override.complexType) this.onComplexType(ct);
-			if (override.simpleType) for (const st of override.simpleType) this.onSimpleType(st);
-			if (override.element) for (const element of override.element) this.onElement(element);
-			if (override.attribute) for (const attr of override.attribute) this.onAttribute(attr);
-			if (override.group) for (const group of override.group) this.onGroup(group);
-			if (override.attributeGroup) for (const group of override.attributeGroup) this.onAttributeGroup(group);
+			this.traverseOverrideChildren(override);
 		}
 		this.source = prevSource;
 	}
+	traverseOverrideChildren(override) {
+		for (const ct of override.complexType ?? []) this.onComplexType(ct);
+		for (const st of override.simpleType ?? []) this.onSimpleType(st);
+		for (const element of override.element ?? []) this.onElement(element);
+		for (const attr of override.attribute ?? []) this.onAttribute(attr);
+		for (const group of override.group ?? []) this.onGroup(group);
+		for (const group of override.attributeGroup ?? []) this.onAttributeGroup(group);
+	}
 	traverseIncludes(schema, depth) {
 		if (!this.options.includeIncludes || !schema.$includes) return;
 		for (const included of schema.$includes) this.traverseSchema(included, "include", depth + 1);
@@ -1122,17 +1115,7 @@ function resolveSchema(schema, options = {}) {
 		includeImports: resolveImports,
 		includeIncludes: resolveIncludes
 	});
-	let elements;
-	if (filterToRootElements) {
-		const referencedElements = /* @__PURE__ */ new Set();
-		for (const el of collector.elements.values()) collectElementRefs(el, referencedElements);
-		for (const ct of collector.complexTypes.values()) collectElementRefsFromType(ct, referencedElements);
-		elements = Array.from(collector.elements.values()).filter((el) => {
-			if (el.abstract === true) return false;
-			if (referencedElements.has(el.name)) return false;
-			return true;
-		});
-	} else elements = Array.from(collector.elements.values());
+	const elements = selectElements(collector, filterToRootElements);
 	let resolvedComplexTypes = Array.from(collector.complexTypes.values());
 	if (expandExtensions) resolvedComplexTypes = resolvedComplexTypes.map((ct) => expandComplexTypeExtension(ct, collector.complexTypes));
 	if (expandSubstitutions) resolvedComplexTypes = resolvedComplexTypes.map((ct) => expandSubstitutionGroupsInType(ct, collector.elements, collector.substitutionGroups));
@@ -1151,6 +1134,22 @@ function resolveSchema(schema, options = {}) {
 	return resolved;
 }
 /**
+* Determine which elements to include in the resolved schema.
+*/
+function selectElements(collector, filterToRootElements) {
+	if (!filterToRootElements) return Array.from(collector.elements.values());
+	const referencedElements = /* @__PURE__ */ new Set();
+	for (const el of collector.elements.values()) collectElementRefs(el, referencedElements);
+	for (const ct of collector.complexTypes.values()) collectElementRefsFromType(ct, referencedElements);
+	return Array.from(collector.elements.values()).filter((el) => isRootElement(el, referencedElements));
+}
+/** An element is a root element when it is not abstract and not referenced. */
+function isRootElement(el, referencedElements) {
+	if (el.abstract === true) return false;
+	if (referencedElements.has(el.name)) return false;
+	return true;
+}
+/**
 * Expand complexContent/extension by merging base type properties.
 * Uses a visited set to prevent infinite recursion on circular inheritance.
 */
@@ -1164,12 +1163,7 @@ function expandComplexTypeExtension(ct, allTypes, visited = /* @__PURE__ */ new
 	const mergedAttributes = [];
 	const baseName = stripNsPrefix(extension.base);
 	const baseType = allTypes.get(baseName);
-	if (baseType && !visited.has(baseName)) {
-		const expandedBase = expandComplexTypeExtension(baseType, allTypes, visited);
-		collectElementsFromType(expandedBase, mergedElements);
-		collectAnysFromType(expandedBase, mergedAnys);
-		if (expandedBase.attribute) mergedAttributes.push(...expandedBase.attribute);
-	}
+	if (baseType && !visited.has(baseName)) mergeBaseTypeContent(baseType, allTypes, visited, mergedElements, mergedAnys, mergedAttributes);
 	collectElementsFromGroup(extension.sequence, mergedElements);
 	collectElementsFromGroup(extension.choice, mergedElements);
 	collectElementsFromGroup(extension.all, mergedElements);
@@ -1177,11 +1171,25 @@ function expandComplexTypeExtension(ct, allTypes, visited = /* @__PURE__ */ new
 	collectAnysFromGroup(extension.choice, mergedAnys);
 	collectAnysFromGroup(extension.all, mergedAnys);
 	if (extension.attribute) mergedAttributes.push(...extension.attribute);
+	return buildFlattenedType(ct, mergedElements, mergedAnys, mergedAttributes);
+}
+/**
+* Recursively expand the base type and merge its content into the accumulators.
+*/
+function mergeBaseTypeContent(baseType, allTypes, visited, mergedElements, mergedAnys, mergedAttributes) {
+	const expandedBase = expandComplexTypeExtension(baseType, allTypes, visited);
+	collectElementsFromType(expandedBase, mergedElements);
+	collectAnysFromType(expandedBase, mergedAnys);
+	if (expandedBase.attribute) mergedAttributes.push(...expandedBase.attribute);
+}
+/**
+* Build the flattened complex type from the merged content,
+* copying over all other properties of the original type.
+*/
+function buildFlattenedType(ct, mergedElements, mergedAnys, mergedAttributes) {
 	const flattened = { name: ct.name };
-	if (mergedElements.length > 0 || mergedAnys.length > 0) flattened.all = {
-		...mergedElements.length > 0 ? { element: mergedElements } : {},
-		...mergedAnys.length > 0 ? { any: mergedAnys } : {}
-	};
+	const all = buildFlattenedAll(mergedElements, mergedAnys);
+	if (all) flattened.all = all;
 	if (mergedAttributes.length > 0) flattened.attribute = mergedAttributes;
 	for (const [key, value] of Object.entries(ct)) if (![
 		"name",
@@ -1194,6 +1202,15 @@ function expandComplexTypeExtension(ct, allTypes, visited = /* @__PURE__ */ new
 	return flattened;
 }
 /**
+* Build the flattened `all` content model, or undefined when there is no content.
+*/
+function buildFlattenedAll(mergedElements, mergedAnys) {
+	const all = {};
+	if (mergedElements.length > 0) all.element = mergedElements;
+	if (mergedAnys.length > 0) all.any = mergedAnys;
+	return Object.keys(all).length > 0 ? all : void 0;
+}
+/**
 * Collect elements from a complex type's content model.
 */
 function collectElementsFromType(ct, elements) {
@@ -1264,23 +1281,11 @@ function expandSubstitutionGroupsInGroup(group, allElements, substitutionGroups)
 	const expandedElements = [];
 	let hasChanges = false;
 	for (const el of group.element) {
-		if (el.ref) {
-			const refName = stripNsPrefix(el.ref);
-			if (allElements.get(refName)?.abstract) {
-				const substitutes = substitutionGroups.get(refName);
-				if (substitutes && substitutes.length > 0) {
-					for (const sub of substitutes) expandedElements.push({
-						name: sub.name,
-						type: sub.type,
-						minOccurs: el.minOccurs ?? 0,
-						maxOccurs: el.maxOccurs
-					});
-					hasChanges = true;
-					continue;
-				}
-			}
-		}
-		expandedElements.push(el);
+		const substitutes = expandAbstractElementRef(el, allElements, substitutionGroups);
+		if (substitutes) {
+			expandedElements.push(...substitutes);
+			hasChanges = true;
+		} else expandedElements.push(el);
 	}
 	if (!hasChanges) return group;
 	return {
@@ -1289,6 +1294,23 @@ function expandSubstitutionGroupsInGroup(group, allElements, substitutionGroups)
 	};
 }
 /**
+* Expand a ref to an abstract element into its substitutes,
+* or return undefined when the element needs no expansion.
+*/
+function expandAbstractElementRef(el, allElements, substitutionGroups) {
+	if (!el.ref) return void 0;
+	const refName = stripNsPrefix(el.ref);
+	if (!allElements.get(refName)?.abstract) return void 0;
+	const substitutes = substitutionGroups.get(refName);
+	if (!substitutes?.length) return void 0;
+	return substitutes.map((sub) => ({
+		name: sub.name,
+		type: sub.type,
+		minOccurs: el.minOccurs ?? 0,
+		maxOccurs: el.maxOccurs
+	}));
+}
+/**
 * Get all substitutes for an abstract element.
 */
 function getSubstitutes(abstractElementName, schema) {
@@ -1314,20 +1336,21 @@ function collectElementRefsFromType(ct, refs) {
 		"choice"
 	]) {
 		const group = record[groupKey];
-		if (group?.element) {
-			const elements = group.element;
-			for (const el of elements) {
-				if (el.ref) {
-					const refName = stripNsPrefix(el.ref);
-					refs.add(refName);
-				}
-				if (el.complexType) collectElementRefsFromType(el.complexType, refs);
-			}
-		}
+		if (group?.element) collectElementRefsFromElements(group.element, refs);
 	}
-	if (record.complexContent) {
-		const cc = record.complexContent;
-		if (cc.extension) collectElementRefsFromType(cc.extension, refs);
+	const cc = record.complexContent;
+	if (cc?.extension) collectElementRefsFromType(cc.extension, refs);
+}
+/**
+* Recursively collect element refs from a list of elements
+*/
+function collectElementRefsFromElements(elements, refs) {
+	for (const el of elements) {
+		if (el.ref) {
+			const refName = stripNsPrefix(el.ref);
+			refs.add(refName);
+		}
+		if (el.complexType) collectElementRefsFromType(el.complexType, refs);
 	}
 }
 
@@ -1447,44 +1470,41 @@ function linkSchema(schema, options) {
 		Object.assign(loadedSchema, { $filename: schemaLocation });
 		inProgress.add(fullPath);
 		cache.set(fullPath, loadedSchema);
-		const newBasePath = dirname(fullPath);
-		linkSchemaInternal(loadedSchema, newBasePath);
+		linkSchemaInternal(loadedSchema, dirname(fullPath), loadAndLink);
 		inProgress.delete(fullPath);
 		return loadedSchema;
 	};
-	const linkSchemaInternal = (s, currentBasePath) => {
-		const imports = [];
-		const includes = [];
-		if (s.import) {
-			for (const imp of s.import) if (imp.schemaLocation) {
-				const linked = loadAndLink(imp.schemaLocation, currentBasePath);
-				if (linked) imports.push(linked);
-			}
-		}
-		if (s.include) {
-			for (const inc of s.include) if (inc.schemaLocation) {
-				const linked = loadAndLink(inc.schemaLocation, currentBasePath);
-				if (linked) includes.push(linked);
-			}
-		}
-		if (s.redefine) {
-			for (const redef of s.redefine) if (redef.schemaLocation) {
-				const linked = loadAndLink(redef.schemaLocation, currentBasePath);
-				if (linked) Object.assign(redef, { $schema: linked });
-			}
-		}
-		if (s.override) {
-			for (const ovr of s.override) if (ovr.schemaLocation) {
-				const linked = loadAndLink(ovr.schemaLocation, currentBasePath);
-				if (linked) Object.assign(ovr, { $schema: linked });
-			}
-		}
-		if (imports.length > 0) Object.assign(s, { $imports: imports });
-		if (includes.length > 0) Object.assign(s, { $includes: includes });
-	};
-	linkSchemaInternal(schema, basePath);
+	linkSchemaInternal(schema, basePath, loadAndLink);
 	return schema;
 }
+/** Process imports/includes/redefines/overrides and link their schemas. */
+function linkSchemaInternal(s, currentBasePath, loadAndLink) {
+	const imports = loadLinkedSchemas(s.import, currentBasePath, loadAndLink);
+	const includes = loadLinkedSchemas(s.include, currentBasePath, loadAndLink);
+	attachBaseSchemas(s.redefine, currentBasePath, loadAndLink);
+	attachBaseSchemas(s.override, currentBasePath, loadAndLink);
+	if (imports.length > 0) Object.assign(s, { $imports: imports });
+	if (includes.length > 0) Object.assign(s, { $includes: includes });
+}
+/** Load and link every referenced schema, skipping missing ones. */
+function loadLinkedSchemas(refs, currentBasePath, loadAndLink) {
+	const linkedSchemas = [];
+	for (const ref of refs ?? []) if (ref.schemaLocation) {
+		const linked = loadAndLink(ref.schemaLocation, currentBasePath);
+		if (linked) linkedSchemas.push(linked);
+	}
+	return linkedSchemas;
+}
+/**
+* Load the base schema of each redefine/override element
+* and attach it to the element as `$schema`.
+*/
+function attachBaseSchemas(refs, currentBasePath, loadAndLink) {
+	for (const ref of refs ?? []) if (ref.schemaLocation) {
+		const linked = loadAndLink(ref.schemaLocation, currentBasePath);
+		if (linked) Object.assign(ref, { $schema: linked });
+	}
+}
 /**
 * Load and link a schema from a file path.
 * Convenience function that combines loadSchema + linkSchema.
@@ -1528,32 +1548,12 @@ async function runCodegen(config, options) {
 		errors: []
 	};
 	const log = verbose ? console.log.bind(console) : () => {};
-	const sources = {};
-	for (const [name, sourceConfig] of Object.entries(config.sources)) {
-		const xsdDir = isAbsolute(sourceConfig.xsdDir) ? sourceConfig.xsdDir : join(rootDir, sourceConfig.xsdDir);
-		let schemas = sourceConfig.schemas;
-		if (sourceConfig.autoLink) schemas = discoverDependentSchemas(sourceConfig.schemas, xsdDir, log);
-		sources[name] = {
-			name,
-			xsdDir,
-			outputDir: isAbsolute(sourceConfig.outputDir) ? sourceConfig.outputDir : join(rootDir, sourceConfig.outputDir),
-			schemas
-		};
-	}
+	const sources = buildSourceInfos(config, rootDir, log);
 	const setupCtx = {
 		sources,
 		rootDir
 	};
-	if (config.clean) {
-		log(`\n🧹 Cleaning output directories...`);
-		for (const source of Object.values(sources)) if (existsSync(source.outputDir)) {
-			rmSync(source.outputDir, {
-				recursive: true,
-				force: true
-			});
-			log(`  ✅ Cleaned ${relative(rootDir, source.outputDir)}`);
-		}
-	}
+	if (config.clean) cleanOutputDirs(sources, rootDir, log);
 	if (config.beforeAll) {
 		log(`\n🔧 Running beforeAll hook...`);
 		await config.beforeAll({
@@ -1565,214 +1565,328 @@ async function runCodegen(config, options) {
 		log(`[${generator.name}] Running setup...`);
 		await generator.setup(setupCtx);
 	}
+	const { processedSchemas, globalAllSchemas } = parseAllSchemas(sources, result, log);
+	await runTransforms({
+		config,
+		sources,
+		processedSchemas,
+		globalAllSchemas,
+		rootDir,
+		dryRun,
+		result,
+		log
+	});
+	await runFinalize(config, sources, processedSchemas, rootDir, dryRun, result, log);
+	await runAfterAll(config, sources, processedSchemas, rootDir, dryRun, result, log);
+	return result;
+}
+/** Build source info map - expand schemas if autoLink is enabled. */
+function buildSourceInfos(config, rootDir, log) {
+	const sources = {};
+	for (const [name, sourceConfig] of Object.entries(config.sources)) {
+		const xsdDir = isAbsolute(sourceConfig.xsdDir) ? sourceConfig.xsdDir : join(rootDir, sourceConfig.xsdDir);
+		let schemas = sourceConfig.schemas;
+		if (sourceConfig.autoLink) schemas = discoverDependentSchemas(sourceConfig.schemas, xsdDir, log);
+		sources[name] = {
+			name,
+			xsdDir,
+			outputDir: isAbsolute(sourceConfig.outputDir) ? sourceConfig.outputDir : join(rootDir, sourceConfig.outputDir),
+			schemas
+		};
+	}
+	return sources;
+}
+/** Clean output directories if requested. */
+function cleanOutputDirs(sources, rootDir, log) {
+	log(`\n🧹 Cleaning output directories...`);
+	for (const source of Object.values(sources)) if (existsSync(source.outputDir)) {
+		rmSync(source.outputDir, {
+			recursive: true,
+			force: true
+		});
+		log(`  ✅ Cleaned ${relative(rootDir, source.outputDir)}`);
+	}
+}
+/**
+* First pass: parse ALL schemas from ALL sources into a global map.
+* This is needed for cross-source type resolution (e.g., custom schemas importing SAP schemas).
+*/
+function parseAllSchemas(sources, result, log) {
 	const processedSchemas = /* @__PURE__ */ new Map();
 	const globalAllSchemas = /* @__PURE__ */ new Map();
-	/**
-	* Recursively discover and parse schemas referenced via xs:include or xs:redefine.
-	* This ensures schemas like types/devc.xsd are in globalAllSchemas when devc.xsd references them.
-	*
-	* @param schema - The parsed schema object
-	* @param xsdDir - The root XSD directory (e.g., '.xsd')
-	* @param currentXsdPath - The path of the current XSD file (for resolving relative paths)
-	* @param sourceName - The source name for logging
-	* @param discovered - Set of already discovered schema names
-	*/
-	function discoverReferencedSchemas(schema, xsdDir, currentXsdPath, sourceName, discovered = /* @__PURE__ */ new Set()) {
-		const includes = schema.include;
-		const redefines = schema.redefine;
-		const refs = [...includes ?? [], ...redefines ?? []];
-		for (const ref of refs) {
-			if (!ref.schemaLocation) continue;
-			const schemaNameWithPath = ref.schemaLocation.replace(/\.xsd$/, "");
-			if (discovered.has(schemaNameWithPath) || globalAllSchemas.has(schemaNameWithPath)) continue;
-			discovered.add(schemaNameWithPath);
-			const currentXsdDir = dirname(currentXsdPath);
-			const refXsdPath = join(currentXsdDir, ref.schemaLocation);
-			if (!existsSync(refXsdPath)) {
-				log(`    ⚠️  Referenced schema not found: ${ref.schemaLocation} (resolved from ${currentXsdDir})`);
-				continue;
-			}
-			try {
-				const refXsdContent = readFileSync(refXsdPath, "utf-8");
-				const refSchema = parseXsd(refXsdContent);
-				refSchema.$filename = ref.schemaLocation;
-				const refSchemaInfo = {
-					name: schemaNameWithPath,
-					xsdContent: refXsdContent,
-					schema: refSchema,
-					sourceName,
-					xsdPath: refXsdPath
-				};
-				globalAllSchemas.set(schemaNameWithPath, refSchemaInfo);
-				log(`    📎 Auto-discovered: ${schemaNameWithPath}`);
-				discoverReferencedSchemas(refSchema, xsdDir, refXsdPath, sourceName, discovered);
-			} catch (error) {
-				const err = error instanceof Error ? error : new Error(String(error));
-				log(`    ⚠️  Failed to parse referenced schema ${ref.schemaLocation}: ${err.message}`);
-			}
-		}
-	}
 	for (const [sourceName, source] of Object.entries(sources)) {
 		log(`\n📦 Processing source: ${sourceName}`);
 		const schemaInfos = [];
 		for (const schemaName of source.schemas) {
-			const xsdPath = join(source.xsdDir, `${schemaName}.xsd`);
-			if (!existsSync(xsdPath)) {
-				log(`  ⚠️  Skipping ${schemaName} - XSD not found`);
-				continue;
-			}
-			try {
-				const xsdContent = readFileSync(xsdPath, "utf-8");
-				const schema = parseXsd(xsdContent);
-				schema.$filename = `${schemaName}.xsd`;
-				const basePath = dirname(xsdPath);
-				linkSchema(schema, {
-					basePath,
-					throwOnMissing: false
-				});
-				const schemaInfo = {
-					name: schemaName,
-					xsdContent,
-					schema,
-					sourceName,
-					xsdPath
-				};
+			const schemaInfo = parseSchemaInfo(schemaName, source, sourceName, globalAllSchemas, result, log);
+			if (schemaInfo) {
 				schemaInfos.push(schemaInfo);
-				globalAllSchemas.set(schemaName, schemaInfo);
 				result.schemas.push({
 					name: schemaName,
 					source: sourceName
 				});
-				discoverReferencedSchemas(schema, source.xsdDir, xsdPath, sourceName);
-			} catch (error) {
-				const err = error instanceof Error ? error : new Error(String(error));
-				log(`  ❌ Failed to parse ${schemaName}: ${err.message}`);
-				result.errors.push({
-					schema: schemaName,
-					source: sourceName,
-					error: err
-				});
 			}
 		}
 		processedSchemas.set(sourceName, schemaInfos);
 	}
+	return {
+		processedSchemas,
+		globalAllSchemas
+	};
+}
+/**
+* Parse and link one schema, registering it and its referenced schemas.
+* Returns undefined (skipping without an error when the file is missing,
+* recording an error when parsing fails).
+*/
+function parseSchemaInfo(schemaName, source, sourceName, globalAllSchemas, result, log) {
+	const xsdPath = join(source.xsdDir, `${schemaName}.xsd`);
+	if (!existsSync(xsdPath)) {
+		log(`  ⚠️  Skipping ${schemaName} - XSD not found`);
+		return;
+	}
+	try {
+		const xsdContent = readFileSync(xsdPath, "utf-8");
+		const schema = parseXsd(xsdContent);
+		schema.$filename = `${schemaName}.xsd`;
+		const basePath = dirname(xsdPath);
+		linkSchema(schema, {
+			basePath,
+			throwOnMissing: false
+		});
+		const schemaInfo = {
+			name: schemaName,
+			xsdContent,
+			schema,
+			sourceName,
+			xsdPath
+		};
+		globalAllSchemas.set(schemaName, schemaInfo);
+		discoverReferencedSchemas(schema, xsdPath, {
+			xsdDir: source.xsdDir,
+			sourceName,
+			discovered: /* @__PURE__ */ new Set(),
+			globalAllSchemas,
+			log
+		});
+		return schemaInfo;
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		log(`  ❌ Failed to parse ${schemaName}: ${err.message}`);
+		result.errors.push({
+			schema: schemaName,
+			source: sourceName,
+			error: err
+		});
+		return;
+	}
+}
+/**
+* Recursively discover and parse schemas referenced via xs:include or xs:redefine.
+* This ensures schemas like types/devc.xsd are in globalAllSchemas when devc.xsd references them.
+*
+* @param schema - The parsed schema object
+* @param currentXsdPath - The path of the current XSD file (for resolving relative paths)
+* @param discovery - Shared discovery state (source, registries, logger)
+*/
+function discoverReferencedSchemas(schema, currentXsdPath, discovery) {
+	const { discovered, globalAllSchemas, log } = discovery;
+	const includes = schema.include;
+	const redefines = schema.redefine;
+	const refs = [...includes ?? [], ...redefines ?? []];
+	for (const ref of refs) {
+		if (!ref.schemaLocation) continue;
+		const schemaNameWithPath = ref.schemaLocation.replace(/\.xsd$/, "");
+		if (discovered.has(schemaNameWithPath) || globalAllSchemas.has(schemaNameWithPath)) continue;
+		discovered.add(schemaNameWithPath);
+		const currentXsdDir = dirname(currentXsdPath);
+		const refXsdPath = join(currentXsdDir, ref.schemaLocation);
+		if (!existsSync(refXsdPath)) {
+			log(`    ⚠️  Referenced schema not found: ${ref.schemaLocation} (resolved from ${currentXsdDir})`);
+			continue;
+		}
+		loadReferencedSchema(ref.schemaLocation, refXsdPath, schemaNameWithPath, discovery);
+	}
+}
+/**
+* Parse one referenced schema, register it in the global map,
+* and recurse into the schemas it references.
+*/
+function loadReferencedSchema(schemaLocation, refXsdPath, schemaNameWithPath, discovery) {
+	const { sourceName, globalAllSchemas, log } = discovery;
+	try {
+		const refXsdContent = readFileSync(refXsdPath, "utf-8");
+		const refSchema = parseXsd(refXsdContent);
+		refSchema.$filename = schemaLocation;
+		const refSchemaInfo = {
+			name: schemaNameWithPath,
+			xsdContent: refXsdContent,
+			schema: refSchema,
+			sourceName,
+			xsdPath: refXsdPath
+		};
+		globalAllSchemas.set(schemaNameWithPath, refSchemaInfo);
+		log(`    📎 Auto-discovered: ${schemaNameWithPath}`);
+		discoverReferencedSchemas(refSchema, refXsdPath, discovery);
+	} catch (error) {
+		log(`    ⚠️  Failed to parse referenced schema ${schemaLocation}: ${(error instanceof Error ? error : new Error(String(error))).message}`);
+	}
+}
+/** Second pass: run transforms with the global schema map. */
+async function runTransforms(ctx) {
+	const { config, sources, processedSchemas, globalAllSchemas, rootDir, dryRun, result, log } = ctx;
 	for (const [sourceName, source] of Object.entries(sources)) {
 		const schemaInfos = processedSchemas.get(sourceName) ?? [];
-		for (const schemaInfo of schemaInfos) {
-			const transformCtx = {
-				schema: schemaInfo,
-				source,
-				allSchemas: globalAllSchemas,
-				allSources: sources,
-				rootDir,
-				resolveImport: createImportResolver(schemaInfo, source, sources, config)
-			};
-			for (const generator of config.generators) if (generator.transform) try {
-				const files = await generator.transform(transformCtx);
-				for (const file of files) {
-					const fullPath = join(source.outputDir, file.path);
-					if (!dryRun) {
-						mkdirSync(dirname(fullPath), { recursive: true });
-						writeFileSync(fullPath, file.content);
-					}
-					result.files.push({
-						path: fullPath,
-						source: sourceName
-					});
-					log(`  ✅ [${generator.name}] Generated ${file.path}`);
-				}
-			} catch (error) {
-				const err = error instanceof Error ? error : new Error(String(error));
-				log(`  ❌ [${generator.name}] Failed ${schemaInfo.name}: ${err.message}`);
-				result.errors.push({
-					schema: schemaInfo.name,
-					source: sourceName,
-					error: err
-				});
+		for (const schemaInfo of schemaInfos) await runTransformPhase(config, {
+			schema: schemaInfo,
+			source,
+			allSchemas: globalAllSchemas,
+			allSources: sources,
+			rootDir,
+			resolveImport: createImportResolver(schemaInfo, source, sources, config)
+		}, source, sourceName, dryRun, result, log);
+	}
+}
+/** Run the transform of every generator for one schema and write the files. */
+async function runTransformPhase(config, transformCtx, source, sourceName, dryRun, result, log) {
+	for (const generator of config.generators) {
+		if (!generator.transform) continue;
+		try {
+			const files = await generator.transform(transformCtx);
+			for (const file of files) {
+				const fullPath = join(source.outputDir, file.path);
+				writeGeneratedFile(fullPath, file.content, {
+					path: fullPath,
+					source: sourceName
+				}, dryRun, result, log, `  ✅ [${generator.name}] Generated ${file.path}`);
 			}
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			log(`  ❌ [${generator.name}] Failed ${transformCtx.schema.name}: ${err.message}`);
+			result.errors.push({
+				schema: transformCtx.schema.name,
+				source: sourceName,
+				error: err
+			});
 		}
 	}
+}
+/** Run finalize for all generators. */
+async function runFinalize(config, sources, processedSchemas, rootDir, dryRun, result, log) {
 	const finalizeCtx = {
 		processedSchemas,
 		sources,
 		rootDir
 	};
-	for (const generator of config.generators) if (generator.finalize) try {
-		log(`\n[${generator.name}] Running finalize...`);
-		const files = await generator.finalize(finalizeCtx);
-		for (const file of files) for (const [sourceName, source] of Object.entries(sources)) {
-			const fullPath = join(source.outputDir, file.path);
-			if (!dryRun) {
-				mkdirSync(dirname(fullPath), { recursive: true });
-				writeFileSync(fullPath, file.content);
-			}
-			result.files.push({
-				path: fullPath,
-				source: sourceName
-			});
-			log(`  ✅ [${generator.name}] Generated ${file.path} for ${sourceName}`);
+	for (const generator of config.generators) {
+		if (!generator.finalize) continue;
+		try {
+			log(`\n[${generator.name}] Running finalize...`);
+			const files = await generator.finalize(finalizeCtx);
+			for (const file of files) writeFinalizeFiles(file, sources, generator.name, dryRun, result, log);
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			log(`  ❌ [${generator.name}] Finalize failed: ${err.message}`);
+			result.errors.push({ error: err });
 		}
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		log(`  ❌ [${generator.name}] Finalize failed: ${err.message}`);
-		result.errors.push({ error: err });
 	}
-	if (config.afterAll) {
-		log(`\n🔧 Running afterAll hook...`);
-		const afterAllCtx = {
-			sources,
-			rootDir,
-			processedSchemas,
-			generatedFiles: result.files.map((f) => ({
-				path: f.path,
-				content: ""
-			}))
-		};
-		const extraFiles = await config.afterAll(afterAllCtx);
-		if (extraFiles && Array.isArray(extraFiles)) for (const file of extraFiles) {
-			const fullPath = join(rootDir, file.path);
-			if (!dryRun) {
-				mkdirSync(dirname(fullPath), { recursive: true });
-				writeFileSync(fullPath, file.content);
-			}
-			result.files.push({
-				path: fullPath,
-				source: "afterAll"
-			});
-			log(`  ✅ [afterAll] Generated ${file.path}`);
-		}
+}
+/** Write one finalize file into every source's output dir. */
+function writeFinalizeFiles(file, sources, generatorName, dryRun, result, log) {
+	for (const [sourceName, source] of Object.entries(sources)) {
+		const fullPath = join(source.outputDir, file.path);
+		writeGeneratedFile(fullPath, file.content, {
+			path: fullPath,
+			source: sourceName
+		}, dryRun, result, log, `  ✅ [${generatorName}] Generated ${file.path} for ${sourceName}`);
+	}
+}
+/** Run the afterAll hook and write any extra files it produces. */
+async function runAfterAll(config, sources, processedSchemas, rootDir, dryRun, result, log) {
+	if (!config.afterAll) return;
+	log(`\n🔧 Running afterAll hook...`);
+	const afterAllCtx = {
+		sources,
+		rootDir,
+		processedSchemas,
+		generatedFiles: result.files.map((f) => ({
+			path: f.path,
+			content: ""
+		}))
+	};
+	const extraFiles = await config.afterAll(afterAllCtx);
+	if (!extraFiles || !Array.isArray(extraFiles)) return;
+	for (const file of extraFiles) {
+		const fullPath = join(rootDir, file.path);
+		writeGeneratedFile(fullPath, file.content, {
+			path: fullPath,
+			source: "afterAll"
+		}, dryRun, result, log, `  ✅ [afterAll] Generated ${file.path}`);
 	}
-	return result;
+}
+/** Write one generated file (skipped in dry run) and record it. */
+function writeGeneratedFile(fullPath, content, record, dryRun, result, log, logMessage) {
+	if (!dryRun) {
+		mkdirSync(dirname(fullPath), { recursive: true });
+		writeFileSync(fullPath, content);
+	}
+	result.files.push(record);
+	log(logMessage);
 }
 function createImportResolver(currentSchema, currentSource, allSources, config) {
 	const ext = config.importExtension ?? "";
 	return (schemaLocation) => {
 		const schemaPath = schemaLocation.replace(/\.xsd$/, "");
 		const schemaBaseName = schemaPath.replace(/^.*\//, "");
-		const currentSchemaDir = dirname(currentSchema.name);
-		const normalizedPath = (currentSchemaDir !== "." ? join(currentSchemaDir, schemaPath).replaceAll(/\\/g, "/") : schemaPath).split("/").reduce((acc, part) => {
-			if (part === "..") acc.pop();
-			else if (part !== ".") acc.push(part);
-			return acc;
-		}, []).join("/");
-		if (currentSource.schemas.includes(normalizedPath)) {
-			const fromDir = dirname(currentSchema.name);
-			const toPath = normalizedPath;
-			const relImport = fromDir === dirname(toPath) ? `./${basename(toPath)}${ext}` : relative(fromDir || ".", toPath).replaceAll(/\\/g, "/") || `./${basename(toPath)}`;
-			return relImport.startsWith(".") ? `${relImport}${ext}` : `./${relImport}${ext}`;
-		}
-		if (currentSource.schemas.includes(schemaPath)) return `./${schemaPath}${ext}`;
-		if (currentSource.schemas.includes(schemaBaseName)) return `./${schemaBaseName}${ext}`;
-		for (const [sourceName, source] of Object.entries(allSources)) {
-			if (sourceName === currentSource.name) continue;
-			if (source.schemas.includes(normalizedPath)) return `${relative(currentSource.outputDir, source.outputDir)}/${normalizedPath}${ext}`.replaceAll(/\\/g, "/");
-			if (source.schemas.includes(schemaPath)) return `${relative(currentSource.outputDir, source.outputDir)}/${schemaPath}${ext}`.replaceAll(/\\/g, "/");
-			if (source.schemas.includes(schemaBaseName)) return `${relative(currentSource.outputDir, source.outputDir)}/${schemaBaseName}${ext}`.replaceAll(/\\/g, "/");
-		}
-		return null;
+		const normalizedPath = normalizeSchemaPath(currentSchema.name, schemaPath);
+		const relImport = resolveInCurrentSource(currentSchema.name, currentSource, normalizedPath, schemaPath, schemaBaseName, ext);
+		if (relImport) return relImport;
+		return resolveInOtherSources(currentSource, allSources, normalizedPath, schemaPath, schemaBaseName, ext);
 	};
 }
 /**
+* Resolve the schemaLocation relative to the current schema's directory
+* and normalize the path (handle ../ etc.).
+* e.g., if current is "sap/classes" and schemaLocation is "adtcore.xsd" -> "sap/adtcore"
+* e.g., if current is "custom/discovery" and schemaLocation is "../sap/atom.xsd" -> "sap/atom"
+*/
+function normalizeSchemaPath(currentSchemaName, schemaPath) {
+	const currentSchemaDir = dirname(currentSchemaName);
+	return (currentSchemaDir !== "." ? join(currentSchemaDir, schemaPath).replaceAll("\\", "/") : schemaPath).split("/").reduce((acc, part) => {
+		if (part === "..") acc.pop();
+		else if (part !== ".") acc.push(part);
+		return acc;
+	}, []).join("/");
+}
+/**
+* Calculate the import path when the target schema is in the current source.
+*/
+function resolveInCurrentSource(currentSchemaName, currentSource, normalizedPath, schemaPath, schemaBaseName, ext) {
+	if (currentSource.schemas.includes(normalizedPath)) {
+		const fromDir = dirname(currentSchemaName);
+		const toPath = normalizedPath;
+		const relImport = fromDir === dirname(toPath) ? `./${basename(toPath)}${ext}` : relative(fromDir || ".", toPath).replaceAll("\\", "/") || `./${basename(toPath)}`;
+		return relImport.startsWith(".") ? `${relImport}${ext}` : `./${relImport}${ext}`;
+	}
+	if (currentSource.schemas.includes(schemaPath)) return `./${schemaPath}${ext}`;
+	if (currentSource.schemas.includes(schemaBaseName)) return `./${schemaBaseName}${ext}`;
+	return null;
+}
+/**
+* Check other sources for the target schema.
+*/
+function resolveInOtherSources(currentSource, allSources, normalizedPath, schemaPath, schemaBaseName, ext) {
+	for (const [sourceName, source] of Object.entries(allSources)) {
+		if (sourceName === currentSource.name) continue;
+		for (const candidate of [
+			normalizedPath,
+			schemaPath,
+			schemaBaseName
+		]) if (source.schemas.includes(candidate)) return `${relative(currentSource.outputDir, source.outputDir)}/${candidate}${ext}`.replaceAll("\\", "/");
+	}
+	return null;
+}
+/**
 * Discover all dependent schemas by recursively parsing XSD files
 * and extracting schemaLocation from xs:import, xs:include, xs:redefine
 */
@@ -1805,30 +1919,21 @@ function discoverDependentSchemas(entrySchemas, xsdDir, log) {
 function extractSchemaLocations(schema, xsdDir, currentSchema) {
 	const locations = [];
 	const currentDir = dirname(join(xsdDir, `${currentSchema}.xsd`));
-	const imports = schema.import;
-	if (imports) {
-		for (const imp of imports) if (imp.schemaLocation) {
-			const name = resolveSchemaName(imp.schemaLocation, currentDir, xsdDir);
-			if (name) locations.push(name);
-		}
-	}
-	const includes = schema.include;
-	if (includes) {
-		for (const inc of includes) if (inc.schemaLocation) {
-			const name = resolveSchemaName(inc.schemaLocation, currentDir, xsdDir);
-			if (name) locations.push(name);
-		}
-	}
-	const redefines = schema.redefine;
-	if (redefines) {
-		for (const red of redefines) if (red.schemaLocation) {
-			const name = resolveSchemaName(red.schemaLocation, currentDir, xsdDir);
-			if (name) locations.push(name);
-		}
-	}
+	collectSchemaLocations(schema.import, currentDir, xsdDir, locations);
+	collectSchemaLocations(schema.include, currentDir, xsdDir, locations);
+	collectSchemaLocations(schema.redefine, currentDir, xsdDir, locations);
 	return locations;
 }
 /**
+* Resolve the schema names of schemaLocation entries and append them.
+*/
+function collectSchemaLocations(refs, currentDir, xsdDir, locations) {
+	for (const ref of refs ?? []) if (ref.schemaLocation) {
+		const name = resolveSchemaName(ref.schemaLocation, currentDir, xsdDir);
+		if (name) locations.push(name);
+	}
+}
+/**
 * Resolve schemaLocation to a schema name relative to xsdDir
 */
 function resolveSchemaName(schemaLocation, currentDir, xsdDir) {
@@ -1839,4 +1944,4 @@ function resolveSchemaName(schemaLocation, currentDir, xsdDir) {
 }
 
 export { getLocalName as _, loadAndLinkSchema as a, getSubstitutes as c, SchemaTraverser as d, resolveSchemaTypes as f, getChildElements as g, getAttributeValue as h, linkSchema as i, resolveSchema as l, getAllChildElements as m, createSchemaLoader as n, loadSchema as o, parseXsd as p, defaultLoader as r, parseSchemaContent as s, runCodegen as t, SchemaResolver as u, getTextContent as v };
-//# sourceMappingURL=runner-BGNA8Sl-.mjs.map
+//# sourceMappingURL=runner-BZNOc_YZ.mjs.map