@abapify/adt-plugin-abapgit 0.4.0 → 0.4.1

package/dist/index.mjs

@@ -0,0 +1,4518 @@
+import { createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
+import { AdkClass, AdkDataElement, AdkDomain, AdkFunctionGroup, AdkInterface, AdkPackage, AdkProgram, AdkStructure, AdkTable, AdkTableType, createAdk, getMainType, getTypeForKind } from "@abapify/adk";
+import { typedSchema } from "@abapify/ts-xsd";
+import { parse } from "@abapify/acds";
+import { tablesettings } from "@abapify/adt-schemas";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { basename, join, relative } from "path";
+import { createAbapGitResolver as createFindingResolver } from "@abapify/adt-atc";
+
+//#region src/lib/handlers/xml-format.ts
+/**
+* XML formatting utilities for abapGit serialization.
+*
+* Centralizes XML post-processing that was previously duplicated
+* across base.ts, fugr.ts, tabl.ts, and roundtrip.ts.
+*
+* Uses indexOf-based parsing instead of regex to avoid
+* super-linear backtracking (SonarQube S5852).
+*/
+/**
+* Extract `name="value"` attribute pairs from an XML attribute string
+* using indexOf-based scanning (no regex).
+*/
+function extractAttributes(content) {
+	const attrs = [];
+	let i = 0;
+	while (i < content.length) {
+		while (i < content.length && (content[i] === " " || content[i] === "\n" || content[i] === "	")) i++;
+		if (i >= content.length) break;
+		const eqIdx = content.indexOf("=", i);
+		if (eqIdx === -1) break;
+		const openQuote = content.indexOf("\"", eqIdx + 1);
+		if (openQuote === -1) break;
+		const closeQuote = content.indexOf("\"", openQuote + 1);
+		if (closeQuote === -1) break;
+		attrs.push(content.slice(i, closeQuote + 1));
+		i = closeQuote + 1;
+	}
+	return attrs;
+}
+/**
+* Format XML attributes on separate lines for better diff readability.
+*
+* Turns `<tag a="1" b="2">` into:
+* ```
+* <tag
+*   a="1"
+*   b="2"
+* >
+* ```
+*
+* Uses indexOf-based scanning to avoid regex backtracking (S5852).
+*/
+function formatXmlAttributes(xml) {
+	let result = "";
+	let pos = 0;
+	while (pos < xml.length) {
+		const openBracket = xml.indexOf("<", pos);
+		if (openBracket === -1) {
+			result += xml.slice(pos);
+			break;
+		}
+		result += xml.slice(pos, openBracket);
+		const closeBracket = xml.indexOf(">", openBracket);
+		if (closeBracket === -1) {
+			result += xml.slice(openBracket);
+			break;
+		}
+		const tagContent = xml.slice(openBracket + 1, closeBracket);
+		const spaceIdx = tagContent.indexOf(" ");
+		if (spaceIdx === -1 || tagContent[0] === "/" || tagContent[0] === "!" || tagContent[0] === "?") {
+			result += xml.slice(openBracket, closeBracket + 1);
+			pos = closeBracket + 1;
+			continue;
+		}
+		const tag = tagContent.slice(0, spaceIdx);
+		const attrPart = tagContent.slice(spaceIdx + 1);
+		const isSelfClosing = attrPart.trimEnd().endsWith("/");
+		const attrs = extractAttributes(isSelfClosing ? attrPart.slice(0, attrPart.lastIndexOf("/")) : attrPart);
+		if (attrs.length === 0) result += xml.slice(openBracket, closeBracket + 1);
+		else {
+			const attrsJoined = attrs.map((a) => `\n  ${a}`).join("");
+			result += `<${tag}${attrsJoined}\n${isSelfClosing ? "/" : ""}>`;
+		}
+		pos = closeBracket + 1;
+	}
+	return result;
+}
+/**
+* Move `xmlns:asx` declaration from root `<abapGit>` to nested `<asx:abap>`.
+*
+* Uses indexOf-based approach instead of regex to avoid backtracking on
+* the `[\s\S]*?` pattern that SonarQube flags.
+*/
+function moveNamespaceToAbap(xml) {
+	const nsDecl = " xmlns:asx=\"http://www.sap.com/abapxml\"";
+	const nsIdx = xml.indexOf(nsDecl);
+	if (nsIdx === -1) return xml;
+	if (xml.lastIndexOf("<abapGit", nsIdx) === -1) return xml;
+	const stripped = xml.slice(0, nsIdx) + xml.slice(nsIdx + 39);
+	const asxIdx = stripped.indexOf("<asx:abap");
+	if (asxIdx === -1) return stripped;
+	return stripped.slice(0, asxIdx + 9) + "\n  " + nsDecl.trim() + stripped.slice(asxIdx + 9);
+}
+/**
+* Apply standard abapGit XML formatting:
+* 1. Format attributes on separate lines
+* 2. Move xmlns:asx to asx:abap element
+*/
+function formatAbapGitXml(xml) {
+	return moveNamespaceToAbap(formatXmlAttributes(xml));
+}
+
+//#endregion
+//#region src/lib/handlers/base.ts
+const handlerRegistry = /* @__PURE__ */ new Map();
+/**
+* Get handler for object type
+*
+* Tries the full type first (e.g., 'TABL/DS'), then falls back to the
+* main type (e.g., 'CLAS/OC' → 'CLAS'). This matches ADK's resolveType()
+* behaviour and handles quickSearch results that return subtypes.
+*/
+function getHandler(type) {
+	return handlerRegistry.get(type) ?? handlerRegistry.get(getMainType(type));
+}
+/**
+* Check if object type is supported
+*
+* Tries the full type first, then falls back to the main type.
+*/
+function isSupported(type) {
+	return handlerRegistry.has(type) || handlerRegistry.has(getMainType(type));
+}
+/**
+* Get all supported object types
+*/
+function getSupportedTypes() {
+	return [...handlerRegistry.keys()];
+}
+/**
+* Create an object handler
+*
+* @param adkClassOrType - ADK object class or ABAP type string
+* @param definition - Handler definition with schema, toAbapGit, serialize
+* @returns ObjectHandler that is auto-registered
+*
+* @example
+* ```typescript
+* // With ADK class (preferred)
+* import { AdkPackage } from '@abapify/adk';
+* export const packageHandler = createHandler(AdkPackage, { ... });
+*
+* // With ABAP type string (for objects without ADK class)
+* export const dataElementHandler = createHandler('DTEL', { ... });
+* ```
+*/
+function createHandler(adkClassOrType, definition) {
+	let type;
+	if (typeof adkClassOrType === "string") type = adkClassOrType;
+	else {
+		const kind = adkClassOrType.kind;
+		const derivedType = getTypeForKind(kind);
+		if (!derivedType) throw new Error(`Unknown ADK kind: ${kind}. Make sure the ADK class has a static 'kind' property.`);
+		type = derivedType;
+	}
+	const fileExtension = getMainType(type).toLowerCase();
+	const ctx = {
+		type,
+		fileExtension,
+		getObjectName(object) {
+			return object.name.toLowerCase();
+		},
+		getData(object) {
+			return object.dataSync;
+		},
+		async resolveContent(content) {
+			if (!content) return "";
+			if (typeof content === "string") return content;
+			if (typeof content === "function") return await content();
+			return "";
+		},
+		toAbapGitXml(object) {
+			const fullPayload = {
+				abap: {
+					version: "1.0",
+					values: definition.toAbapGit(object)
+				},
+				version: definition.version,
+				serializer: definition.serializer,
+				serializer_version: definition.serializer_version
+			};
+			return formatAbapGitXml(definition.schema.build(fullPayload, { pretty: true }));
+		},
+		createFile(path, content, encoding) {
+			return {
+				path,
+				content,
+				encoding
+			};
+		},
+		createXmlFile(objectName, xmlContent) {
+			return {
+				path: `${objectName}.${fileExtension}.xml`,
+				content: xmlContent
+			};
+		},
+		createAbapFile(objectName, content, suffix) {
+			return {
+				path: suffix ? `${objectName}.${fileExtension}.${suffix}.abap` : `${objectName}.${fileExtension}.abap`,
+				content
+			};
+		}
+	};
+	const defaultSerialize = async (object) => {
+		const objectName = ctx.getObjectName(object);
+		const files = [];
+		if (definition.getSources) {
+			const rawSources = definition.getSources(object);
+			const sources = await Promise.all(rawSources.map(async ({ suffix, content }) => ({
+				suffix,
+				content: await content
+			})));
+			for (const { suffix, content } of sources) if (content) files.push(ctx.createAbapFile(objectName, content, suffix));
+		} else if (definition.getSource) {
+			const source = await definition.getSource(object);
+			files.push(ctx.createAbapFile(objectName, source));
+		}
+		const xmlContent = ctx.toAbapGitXml(object);
+		let xmlFileName;
+		if (definition.xmlFileName) xmlFileName = typeof definition.xmlFileName === "function" ? definition.xmlFileName(object, ctx) : definition.xmlFileName;
+		else xmlFileName = `${objectName}.${fileExtension}.xml`;
+		files.push(ctx.createFile(xmlFileName, xmlContent));
+		return files;
+	};
+	const defaultFromAbapGit = definition.fromAbapGit ? (values) => {
+		return definition.fromAbapGit(values);
+	} : void 0;
+	const handler = {
+		type,
+		fileExtension,
+		schema: definition.schema,
+		suffixToSourceKey: definition.suffixToSourceKey,
+		serialize: definition.serialize ? (object) => definition.serialize(object, ctx) : defaultSerialize,
+		fromAbapGit: defaultFromAbapGit,
+		setSources: definition.setSources
+	};
+	handlerRegistry.set(type, handler);
+	return handler;
+}
+
+//#endregion
+//#region src/lib/handlers/abapgit-schema.ts
+/**
+* AbapGit Schema - extends TypedSchema with values type
+*
+* Provides both:
+* - _type: Full AbapGitType (for XML build/parse)
+* - _values: Inner values type (for handler mapping)
+*/
+/**
+* Create an AbapGit typed schema wrapper from raw schema
+*
+* @param rawSchema - Raw schema literal (with `as const`)
+* @returns AbapGitSchema with both _type and _values
+*
+* @example
+* ```typescript
+* import _devc from './schemas/devc';
+*
+* const devc = abapGitSchema<DevcAbapGitType, DevcType>(_devc);
+*
+* // Access types:
+* type Full = typeof devc._type;    // DevcAbapGitType
+* type Values = typeof devc._values; // DevcType
+* ```
+*/
+function abapGitSchema(rawSchema) {
+	const base = typedSchema(rawSchema);
+	return {
+		_type: base._type,
+		_values: null,
+		schema: base.schema,
+		parse: base.parse,
+		build: base.build
+	};
+}
+
+//#endregion
+//#region src/schemas/generated/schemas/clas.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/clas.xsd
+*/
+var clas_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "VSEOCLASS",
+				type: "asx:VseoClassType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "VseoClassType",
+			all: { element: [
+				{
+					name: "CLSNAME",
+					type: "xs:string"
+				},
+				{
+					name: "LANGU",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DESCRIPT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "STATE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CATEGORY",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "EXPOSURE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CLSFINAL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CLSABSTRCT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CLSCCINCL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIXPT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UNICODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "WITH_UNIT_TESTS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DURATION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "RISK",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MSG_ID",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFCLSNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHRM_ENABLED",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ABAP_LANGUAGE_VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/devc.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/devc.xsd
+*/
+var devc_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "DEVC",
+				type: "asx:DevcType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "DevcType",
+			all: { element: [{
+				name: "CTEXT",
+				type: "xs:string"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/doma.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/doma.xsd
+*/
+var doma_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "DD01V",
+				type: "asx:Dd01vType",
+				minOccurs: "0"
+			}, {
+				name: "DD07V_TAB",
+				type: "asx:Dd07vTabType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "Dd01vType",
+			all: { element: [
+				{
+					name: "DOMNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DATATYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LENG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OUTPUTLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DECIMALS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LOWERCASE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SIGNFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VALEXI",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ENTITYTAB",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONVEXIT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DOMMASTER",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd07vType",
+			all: { element: [
+				{
+					name: "DOMNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VALPOS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DOMVALUE_L",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DOMVALUE_H",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd07vTabType",
+			sequence: { element: [{
+				name: "DD07V",
+				type: "Dd07vType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/dtel.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/dtel.xsd
+*/
+var dtel_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "DD04V",
+				type: "asx:Dd04vType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "Dd04vType",
+			sequence: { element: [
+				{
+					name: "ROLLNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DOMNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "HEADLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRLEN1",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRLEN2",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRLEN3",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REPTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRTEXT_S",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRTEXT_M",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCRTEXT_L",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DTELMASTER",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DATATYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LENG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DECIMALS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OUTPUTLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFKIND",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ABAP_LANGUAGE_VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/intf.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/intf.xsd
+*/
+var intf_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "VSEOINTERF",
+				type: "asx:VseoInterfType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "VseoInterfType",
+			all: { element: [
+				{
+					name: "CLSNAME",
+					type: "xs:string"
+				},
+				{
+					name: "LANGU",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DESCRIPT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "EXPOSURE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "STATE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UNICODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ABAP_LANGUAGE_VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/prog.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/prog.xsd
+*/
+var prog_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	elementFormDefault: "unqualified",
+	element: [{
+		name: "abapGit",
+		complexType: {
+			sequence: { element: [{
+				name: "abap",
+				type: "ProgAbapType"
+			}] },
+			attribute: [
+				{
+					name: "version",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer_version",
+					type: "xs:string",
+					use: "required"
+				}
+			]
+		}
+	}, {
+		name: "Schema",
+		abstract: true
+	}],
+	complexType: [
+		{
+			name: "ProgValuesType",
+			all: { element: [{
+				name: "PROGDIR",
+				type: "ProgdirType",
+				minOccurs: "0"
+			}, {
+				name: "TPOOL",
+				type: "TpoolType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "ProgAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "ProgValuesType"
+			}] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "AbapValuesType",
+			sequence: { element: [{
+				ref: "asx:Schema",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "ProgdirType",
+			all: { element: [
+				{
+					name: "NAME",
+					type: "xs:string"
+				},
+				{
+					name: "STATE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SUBC",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIXPT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UNICODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DTEFUNC",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "RLOAD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UCCHECK",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ABAP_LANGUAGE_VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TpoolItemType",
+			all: { element: [
+				{
+					name: "ID",
+					type: "xs:string"
+				},
+				{
+					name: "ENTRY",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LENGTH",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TpoolType",
+			sequence: { element: [{
+				name: "item",
+				type: "TpoolItemType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/fugr.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/fugr.xsd
+*/
+var fugr_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	elementFormDefault: "unqualified",
+	element: [{
+		name: "abapGit",
+		complexType: {
+			sequence: { element: [{
+				name: "abap",
+				type: "FugrAbapType"
+			}] },
+			attribute: [
+				{
+					name: "version",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer_version",
+					type: "xs:string",
+					use: "required"
+				}
+			]
+		}
+	}, {
+		name: "Schema",
+		abstract: true
+	}],
+	complexType: [
+		{
+			name: "FugrValuesType",
+			all: { element: [
+				{
+					name: "AREAT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "INCLUDES",
+					type: "FugrIncludesType",
+					minOccurs: "0"
+				},
+				{
+					name: "FUNCTIONS",
+					type: "FugrFunctionsType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "FugrAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "FugrValuesType"
+			}] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "AbapValuesType",
+			sequence: { element: [{
+				ref: "asx:Schema",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "FugrParamType",
+			all: { element: [
+				{
+					name: "PARAMETER",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TYP",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DBFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DEFAULT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OPTIONAL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFERENCE",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "FugrTableParamType",
+			all: { element: [
+				{
+					name: "PARAMETER",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DBSTRUCT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TYP",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OPTIONAL",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "FugrExceptionType",
+			all: { element: [{
+				name: "EXCEPTION",
+				type: "xs:string",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "FugrDocParamType",
+			all: { element: [
+				{
+					name: "PARAMETER",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KIND",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "STEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "FugrImportType",
+			sequence: { element: [{
+				name: "RSIMP",
+				type: "FugrParamType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrExportType",
+			sequence: { element: [{
+				name: "RSEXP",
+				type: "FugrParamType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrChangingType",
+			sequence: { element: [{
+				name: "RSCHA",
+				type: "FugrParamType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrTablesType",
+			sequence: { element: [{
+				name: "RSTBL",
+				type: "FugrTableParamType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrExceptionsType",
+			sequence: { element: [{
+				name: "RSEXC",
+				type: "FugrExceptionType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrDocumentationType",
+			sequence: { element: [{
+				name: "RSFDO",
+				type: "FugrDocParamType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrFunctionItemType",
+			all: { element: [
+				{
+					name: "FUNCNAME",
+					type: "xs:string"
+				},
+				{
+					name: "GLOBAL_FLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REMOTE_CALL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UPDATE_TASK",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHORT_TEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REMOTE_BASXML",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "EXCEPTION_CLASSES",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "IMPORT",
+					type: "FugrImportType",
+					minOccurs: "0"
+				},
+				{
+					name: "CHANGING",
+					type: "FugrChangingType",
+					minOccurs: "0"
+				},
+				{
+					name: "EXPORT",
+					type: "FugrExportType",
+					minOccurs: "0"
+				},
+				{
+					name: "TABLES",
+					type: "FugrTablesType",
+					minOccurs: "0"
+				},
+				{
+					name: "EXCEPTION",
+					type: "FugrExceptionsType",
+					minOccurs: "0"
+				},
+				{
+					name: "DOCUMENTATION",
+					type: "FugrDocumentationType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "FugrFunctionsType",
+			sequence: { element: [{
+				name: "item",
+				type: "FugrFunctionItemType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "FugrIncludesType",
+			sequence: { element: [{
+				name: "SOBJ_NAME",
+				type: "xs:string",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/tabl.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/tabl.xsd
+*/
+var tabl_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [
+				{
+					name: "DD02V",
+					type: "asx:Dd02vType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD09L",
+					type: "asx:Dd09lType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD03P_TABLE",
+					type: "asx:Dd03pTableType",
+					minOccurs: "0"
+				},
+				{
+					name: "TABL_EXTRAS",
+					type: "asx:TablExtrasType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd02vType",
+			sequence: { element: [
+				{
+					name: "TABNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LANGDEP",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CLIDEP",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SQLTAB",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DATCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MASTERLANG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "BUFFERED",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MATEFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONTFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPEXI",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "EXCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "AUTHCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd09lType",
+			sequence: { element: [
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "AS4LOCAL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABKAT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABART",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "BUFALLOW",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "PUFFERUNG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SCHFELDANZ",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "PROTOKOLL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SPEESSION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "UESSION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROESSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd03pType",
+			sequence: { element: [
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "POSITION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KEYFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROLLNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ADMINFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "INTTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "INTLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFTABLE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "PRECFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "NOTNULL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DATATYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LENG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DECIMALS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DOMNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MASK",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPORIGIN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "COMPTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONRFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd03pTableType",
+			sequence: { element: [{
+				name: "DD03P",
+				type: "Dd03pType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "TddatType",
+			sequence: { element: [
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VIEWGRANT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TVDIR",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "GENERICRANGE",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TablExtrasType",
+			sequence: { element: [{
+				name: "TDDAT",
+				type: "TddatType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/ttyp.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/ttyp.xsd
+*/
+var ttyp_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	targetNamespace: "http://www.sap.com/abapxml",
+	elementFormDefault: "unqualified",
+	element: [
+		{
+			name: "abapGit",
+			complexType: {
+				sequence: { element: [{ ref: "asx:abap" }] },
+				attribute: [
+					{
+						name: "version",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer",
+						type: "xs:string",
+						use: "required"
+					},
+					{
+						name: "serializer_version",
+						type: "xs:string",
+						use: "required"
+					}
+				]
+			}
+		},
+		{
+			name: "Schema",
+			abstract: true
+		},
+		{
+			name: "values",
+			type: "asx:AbapValuesType"
+		},
+		{
+			name: "abap",
+			type: "asx:AbapType"
+		}
+	],
+	complexType: [
+		{
+			name: "AbapValuesType",
+			all: { element: [{
+				name: "DD40V",
+				type: "asx:Dd40vType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "Dd40vType",
+			all: { element: [
+				{
+					name: "TYPENAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROWTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROWKIND",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DATATYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ACCESSMODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KEYDEF",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KEYKIND",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "GENERIC",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LENG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DECIMALS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TYPELEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DEFFDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ABAP_LANGUAGE_VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/bdef.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/bdef.xsd
+*/
+var bdef_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	elementFormDefault: "unqualified",
+	element: [{
+		name: "abapGit",
+		complexType: {
+			sequence: { element: [{
+				name: "abap",
+				type: "BdefAbapType"
+			}] },
+			attribute: [
+				{
+					name: "version",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer_version",
+					type: "xs:string",
+					use: "required"
+				}
+			]
+		}
+	}, {
+		name: "Schema",
+		abstract: true
+	}],
+	complexType: [
+		{
+			name: "SkeyType",
+			all: { element: [{
+				name: "TYPE",
+				type: "xs:string",
+				minOccurs: "0"
+			}, {
+				name: "NAME",
+				type: "xs:string",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "BdefValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "BdefAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "BdefValuesType"
+			}] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "AbapValuesType",
+			sequence: { element: [{
+				ref: "asx:Schema",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/srvd.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/srvd.xsd
+*/
+var srvd_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	elementFormDefault: "unqualified",
+	element: [{
+		name: "abapGit",
+		complexType: {
+			sequence: { element: [{
+				name: "abap",
+				type: "SrvdAbapType"
+			}] },
+			attribute: [
+				{
+					name: "version",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer_version",
+					type: "xs:string",
+					use: "required"
+				}
+			]
+		}
+	}, {
+		name: "Schema",
+		abstract: true
+	}],
+	complexType: [
+		{
+			name: "SkeyType",
+			all: { element: [{
+				name: "TYPE",
+				type: "xs:string",
+				minOccurs: "0"
+			}, {
+				name: "NAME",
+				type: "xs:string",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "SrvdValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "SrvdAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "SrvdValuesType"
+			}] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "AbapValuesType",
+			sequence: { element: [{
+				ref: "asx:Schema",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/schemas/srvb.ts
+/**
+* Auto-generated schema from XSD
+* 
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/srvb.xsd
+*/
+var srvb_default = {
+	$xmlns: {
+		xs: "http://www.w3.org/2001/XMLSchema",
+		asx: "http://www.sap.com/abapxml"
+	},
+	elementFormDefault: "unqualified",
+	element: [{
+		name: "abapGit",
+		complexType: {
+			sequence: { element: [{
+				name: "abap",
+				type: "SrvbAbapType"
+			}] },
+			attribute: [
+				{
+					name: "version",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer",
+					type: "xs:string",
+					use: "required"
+				},
+				{
+					name: "serializer_version",
+					type: "xs:string",
+					use: "required"
+				}
+			]
+		}
+	}, {
+		name: "Schema",
+		abstract: true
+	}],
+	complexType: [
+		{
+			name: "SkeyType",
+			all: { element: [{
+				name: "TYPE",
+				type: "xs:string",
+				minOccurs: "0"
+			}, {
+				name: "NAME",
+				type: "xs:string",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "BindingType",
+			all: { element: [
+				{
+					name: "TYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VERSION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CATEGORY",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "SrvbValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}, {
+				name: "BINDING",
+				type: "BindingType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "SrvbAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "SrvbValuesType"
+			}] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		},
+		{
+			name: "AbapValuesType",
+			sequence: { element: [{
+				ref: "asx:Schema",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "AbapType",
+			sequence: { element: [{ ref: "asx:values" }] },
+			attribute: [{
+				name: "version",
+				type: "xs:string",
+				"default": "1.0"
+			}]
+		}
+	]
+};
+
+//#endregion
+//#region src/schemas/generated/index.ts
+/**
+* AbapGit Typed Schemas
+* 
+* Auto-generated by ts-xsd codegen - DO NOT EDIT
+* 
+* Each schema provides:
+* - _type: Full AbapGitType (for XML build/parse)
+* - _values: Inner values type (for handler mapping)
+* - parse(xml) → fully typed object
+* - build(data) → XML string
+* - schema → raw schema literal
+*/
+const clas = abapGitSchema(clas_default);
+const devc = abapGitSchema(devc_default);
+const doma = abapGitSchema(doma_default);
+const dtel = abapGitSchema(dtel_default);
+const intf = abapGitSchema(intf_default);
+const prog = abapGitSchema(prog_default);
+const fugr = abapGitSchema(fugr_default);
+const tabl = abapGitSchema(tabl_default);
+const ttyp = abapGitSchema(ttyp_default);
+const bdef = abapGitSchema(bdef_default);
+const srvd = abapGitSchema(srvd_default);
+const srvb = abapGitSchema(srvb_default);
+
+//#endregion
+//#region src/lib/handlers/lang.ts
+/**
+* SAP 1-character language code ↔ ISO 639-1 mapping
+*
+* abapGit stores SAP internal 1-char codes (e.g. "E" for English).
+* SAP ADT REST API expects ISO 639-1 codes (e.g. "EN").
+*/
+const SAP_TO_ISO = {
+	E: "EN",
+	D: "DE",
+	F: "FR",
+	I: "IT",
+	S: "ES",
+	P: "PT",
+	J: "JA",
+	K: "KO",
+	"1": "ZH",
+	W: "RU",
+	T: "TR",
+	N: "NL",
+	H: "HU",
+	L: "PL",
+	Q: "CS",
+	R: "SK",
+	U: "SV",
+	V: "DA",
+	Y: "FI",
+	X: "NO",
+	G: "EL",
+	B: "HE",
+	A: "AR",
+	"3": "TH",
+	M: "UK",
+	"6": "HR",
+	O: "SL",
+	"7": "BG",
+	"8": "SR",
+	C: "RO"
+};
+const ISO_TO_SAP = Object.fromEntries(Object.entries(SAP_TO_ISO).map(([k, v]) => [v, k]));
+/**
+* Convert SAP 1-char language code to ISO 639-1.
+* Returns the input uppercased if no mapping exists (may already be ISO).
+*/
+function sapLangToIso(sapLang) {
+	if (!sapLang) return "EN";
+	const upper = sapLang.toUpperCase();
+	if (upper.length >= 2) return upper;
+	return SAP_TO_ISO[upper] ?? upper;
+}
+/**
+* Convert ISO 639-1 language code to SAP 1-char code.
+* Returns "E" (English) if no mapping exists.
+*/
+function isoToSapLang(isoLang) {
+	if (!isoLang) return "E";
+	const upper = isoLang.toUpperCase();
+	if (upper.length === 1) return upper;
+	return ISO_TO_SAP[upper] ?? "E";
+}
+/**
+* abapGit numeric code → ADT API string value
+*
+* abapGit serializes ABAP_LANGUAGE_VERSION as a numeric string (e.g. "5").
+* SAP ADT REST API expects descriptive strings (e.g. "cloudDevelopment").
+*/
+const ABAP_LANG_VER_TO_ADT = {
+	"2": "keyUser",
+	"5": "cloudDevelopment"
+};
+const ABAP_LANG_VER_FROM_ADT = Object.fromEntries(Object.entries(ABAP_LANG_VER_TO_ADT).map(([k, v]) => [v, k]));
+/**
+* Convert abapGit ABAP_LANGUAGE_VERSION code to ADT API value.
+* Returns undefined if not set or standard ABAP.
+* Passes through values that are already in ADT format (e.g. "cloudDevelopment").
+*/
+function abapLangVerToAdt(abapGitCode) {
+	if (!abapGitCode) return void 0;
+	return ABAP_LANG_VER_TO_ADT[abapGitCode] ?? abapGitCode;
+}
+/**
+* Convert ADT API abapLanguageVersion to abapGit ABAP_LANGUAGE_VERSION code.
+* Returns undefined if not set or standard ABAP (default — should not be emitted).
+*/
+function abapLangVerFromAdt(adtValue) {
+	if (!adtValue) return void 0;
+	if (adtValue === "standard" || adtValue === "X") return void 0;
+	return ABAP_LANG_VER_FROM_ADT[adtValue] ?? adtValue;
+}
+
+//#endregion
+//#region src/lib/handlers/objects/clas.ts
+/**
+* Class (CLAS) object handler for abapGit format
+*/
+/**
+* Map ADK ClassIncludeType to abapGit file suffix convention
+* Used for serialization (SAP → Git)
+*/
+const ABAPGIT_SUFFIX = {
+	main: void 0,
+	definitions: "locals_def",
+	implementations: "locals_imp",
+	localtypes: "locals_types",
+	macros: "macros",
+	testclasses: "testclasses"
+};
+/**
+* Reverse mapping: abapGit file suffix to ADK source key
+* Derived from ABAPGIT_SUFFIX to avoid duplication
+*/
+const SUFFIX_TO_SOURCE_KEY = Object.fromEntries(Object.entries(ABAPGIT_SUFFIX).filter(([, suffix]) => suffix !== void 0).map(([key, suffix]) => [suffix, key]));
+/**
+* Map ADT category enum → abapGit numeric code
+* SAP ADT returns string names, abapGit uses numeric codes from SEOCLASSDF-CATEGORY
+*/
+const CATEGORY_FROM_ADT = {
+	generalObjectType: "00",
+	exitClass: "01",
+	testClass: "02",
+	areaClass: "03",
+	factoryClass: "04",
+	persistentClass: "30",
+	exceptionClass: "40",
+	bspClass: "60",
+	staticTypedLcpClass: "70",
+	behaviorPool: "80",
+	rfcProxyClass: "90",
+	entityEventHandler: "100",
+	communicationConnectionClass: "110"
+};
+/**
+* Map visibility to EXPOSURE code (ADK → abapGit)
+*/
+const VISIBILITY_TO_EXPOSURE = {
+	private: "0",
+	protected: "1",
+	public: "2"
+};
+/**
+* Reverse mapping: EXPOSURE code to visibility (abapGit → ADK)
+*/
+const EXPOSURE_TO_VISIBILITY = Object.fromEntries(Object.entries(VISIBILITY_TO_EXPOSURE).map(([k, v]) => [v, k]));
+const classHandler = createHandler(AdkClass, {
+	schema: clas,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_CLAS",
+	serializer_version: "v1.0.0",
+	suffixToSourceKey: SUFFIX_TO_SOURCE_KEY,
+	toAbapGit: (cls) => {
+		const data = cls.dataSync;
+		const hasTestClasses = (data.include ?? []).some((inc) => String(inc.includeType) === "testclasses") || data.hasTests === true || data.withUnitTests === true;
+		const categoryCode = CATEGORY_FROM_ADT[data.category ?? ""] ?? data.category ?? "00";
+		const exposureCode = VISIBILITY_TO_EXPOSURE[data.visibility ?? "public"] ?? "2";
+		return { VSEOCLASS: {
+			CLSNAME: cls.name ?? "",
+			LANGU: isoToSapLang(data.language),
+			DESCRIPT: data.description ?? "",
+			STATE: "1",
+			CATEGORY: categoryCode !== "00" ? categoryCode : void 0,
+			EXPOSURE: exposureCode !== "2" ? exposureCode : void 0,
+			CLSFINAL: data.final ? "X" : void 0,
+			CLSABSTRCT: data.abstract ? "X" : void 0,
+			SHRM_ENABLED: data.sharedMemoryEnabled ? "X" : void 0,
+			CLSCCINCL: "X",
+			FIXPT: data.fixPointArithmetic ? "X" : void 0,
+			UNICODE: "X",
+			REFCLSNAME: data.superClassRef?.name,
+			MSG_ID: data.messageClassRef?.name,
+			ABAP_LANGUAGE_VERSION: abapLangVerFromAdt(data.abapLanguageVersion),
+			...hasTestClasses ? { WITH_UNIT_TESTS: "X" } : {}
+		} };
+	},
+	getSources: (cls) => {
+		return (cls.dataSync.include ?? []).map((inc) => ({
+			suffix: ABAPGIT_SUFFIX[String(inc.includeType ?? "main")],
+			content: cls.getIncludeSource(String(inc.includeType ?? "main"))
+		}));
+	},
+	fromAbapGit: ({ VSEOCLASS }) => ({
+		name: (VSEOCLASS?.CLSNAME ?? "").toUpperCase(),
+		type: "CLAS/OC",
+		description: VSEOCLASS?.DESCRIPT,
+		language: sapLangToIso(VSEOCLASS?.LANGU),
+		masterLanguage: sapLangToIso(VSEOCLASS?.LANGU),
+		category: VSEOCLASS?.CATEGORY,
+		final: VSEOCLASS?.CLSFINAL === "X",
+		abstract: VSEOCLASS?.CLSABSTRCT === "X",
+		visibility: EXPOSURE_TO_VISIBILITY[VSEOCLASS?.EXPOSURE ?? "2"] ?? "public",
+		sharedMemoryEnabled: VSEOCLASS?.SHRM_ENABLED === "X",
+		fixPointArithmetic: VSEOCLASS?.FIXPT === "X",
+		activeUnicodeCheck: VSEOCLASS?.UNICODE === "X",
+		withUnitTests: VSEOCLASS?.WITH_UNIT_TESTS === "X",
+		superClassRef: VSEOCLASS?.REFCLSNAME ? { name: VSEOCLASS.REFCLSNAME } : void 0,
+		messageClassRef: VSEOCLASS?.MSG_ID ? { name: VSEOCLASS.MSG_ID } : void 0,
+		abapLanguageVersion: abapLangVerToAdt(VSEOCLASS?.ABAP_LANGUAGE_VERSION)
+	}),
+	setSources: (cls, sources) => {
+		cls._pendingSources = sources;
+		if (sources.main) cls._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/intf.ts
+/**
+* Interface (INTF) object handler for abapGit format
+*/
+const interfaceHandler = createHandler(AdkInterface, {
+	schema: intf,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_INTF",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ VSEOINTERF: {
+		CLSNAME: obj.name ?? "",
+		LANGU: isoToSapLang(obj.dataSync?.language),
+		DESCRIPT: obj.description ?? "",
+		EXPOSURE: "2",
+		STATE: "1",
+		UNICODE: "X"
+	} }),
+	getSource: (obj) => obj.getSource(),
+	fromAbapGit: ({ VSEOINTERF }) => ({
+		name: (VSEOINTERF?.CLSNAME ?? "").toUpperCase(),
+		type: "INTF/OI",
+		description: VSEOINTERF?.DESCRIPT,
+		language: sapLangToIso(VSEOINTERF?.LANGU),
+		masterLanguage: sapLangToIso(VSEOINTERF?.LANGU),
+		abapLanguageVersion: abapLangVerToAdt(VSEOINTERF?.ABAP_LANGUAGE_VERSION)
+	}),
+	setSources: (intf, sources) => {
+		if (sources.main) intf._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/devc.ts
+/**
+* Package (DEVC) object handler for abapGit format
+*/
+/**
+* Package handler for abapGit serialization
+*
+* Note: Packages in abapGit use "package.devc.xml" as filename,
+* not "$packagename.devc.xml"
+*/
+const packageHandler = createHandler(AdkPackage, {
+	schema: devc,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_DEVC",
+	serializer_version: "v1.0.0",
+	xmlFileName: "package.devc.xml",
+	toAbapGit: (pkg) => ({ DEVC: { CTEXT: pkg.description ?? "" } }),
+	fromAbapGit: ({ DEVC }) => ({
+		name: "",
+		description: DEVC?.CTEXT
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/prog.ts
+/**
+* Program (PROG) object handler for abapGit format
+*/
+const programHandler = createHandler(AdkProgram, {
+	schema: prog,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_PROG",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ PROGDIR: {
+		NAME: obj.name ?? "",
+		STATE: "A",
+		SUBC: "1",
+		FIXPT: "X",
+		UNICODE: "X"
+	} }),
+	getSource: (obj) => obj.getSource(),
+	fromAbapGit: ({ PROGDIR, TPOOL }) => {
+		const rawItems = TPOOL?.item ?? [];
+		const descriptionEntry = (Array.isArray(rawItems) ? rawItems : [rawItems]).find((t) => t.ID === "R");
+		const subc = String(PROGDIR?.SUBC ?? "");
+		return {
+			name: (PROGDIR?.NAME ?? "").toUpperCase(),
+			type: "PROG/P",
+			description: descriptionEntry?.ENTRY ?? "Program",
+			fixPointArithmetic: PROGDIR?.FIXPT === "X",
+			activeUnicodeCheck: PROGDIR?.UNICODE === "X",
+			programType: subc === "1" ? "executableProgram" : "subroutinePool"
+		};
+	},
+	setSources: (obj, sources) => {
+		if (sources.main) obj._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/fugr.ts
+/**
+* Function Group (FUGR) object handler for abapGit format
+*
+* FUGR is a compound object — abapGit serializes it as multiple files:
+*   {name}.fugr.xml                      — Main metadata (AREAT + INCLUDES + FUNCTIONS)
+*   {name}.fugr.l{name}top.abap          — TOP-include source (editable)
+*   {name}.fugr.l{name}top.xml           — TOP-include PROGDIR metadata
+*   {name}.fugr.sapl{name}.abap          — Main program source (system-generated)
+*   {name}.fugr.sapl{name}.xml           — Main program PROGDIR metadata
+*   {name}.fugr.{funcname}.abap          — Function module source (per FM)
+*
+* Note: FM metadata is stored INSIDE the main XML under <FUNCTIONS>,
+* NOT in separate per-FM XML files (that's how abapGit works).
+*/
+/**
+* Map ADT processingType to abapGit REMOTE_CALL flag
+*/
+function processingTypeToRemoteCall(processingType) {
+	switch (processingType) {
+		case "rfc": return "R";
+		case "update": return;
+		default: return;
+	}
+}
+/**
+* Map abapGit REMOTE_CALL flag to ADT processingType
+*/
+function remoteCallToProcessingType(remoteCall, updateTask) {
+	if (remoteCall === "R") return "rfc";
+	if (updateTask && updateTask !== "" && updateTask !== " ") return "update";
+	return "normal";
+}
+const functionGroupHandler = createHandler(AdkFunctionGroup, {
+	schema: fugr,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_FUGR",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const name = obj.name.toUpperCase();
+		return {
+			AREAT: obj.description ?? "",
+			INCLUDES: { SOBJ_NAME: [`L${name}TOP`, `SAPL${name}`] }
+		};
+	},
+	serialize: async (obj, ctx) => {
+		const objectName = ctx.getObjectName(obj);
+		const nameUpper = obj.name.toUpperCase();
+		const files = [];
+		const fmItems = await discoverFunctionModules(obj);
+		const functions = await serializeFunctions(obj, fmItems);
+		const values = {
+			AREAT: obj.description ?? "",
+			INCLUDES: { SOBJ_NAME: [`L${nameUpper}TOP`, `SAPL${nameUpper}`] }
+		};
+		if (functions.length > 0) values.FUNCTIONS = { item: functions };
+		const fullPayload = { abapGit: {
+			abap: {
+				version: "1.0",
+				values
+			},
+			version: "v1.0.0",
+			serializer: "LCL_OBJECT_FUGR",
+			serializer_version: "v1.0.0"
+		} };
+		let xmlContent = fugr.build(fullPayload, { pretty: true });
+		xmlContent = formatAbapGitXml(xmlContent);
+		files.push(ctx.createFile(`${objectName}.fugr.xml`, xmlContent));
+		try {
+			const topSource = await obj.getSource();
+			if (topSource) files.push(ctx.createFile(`${objectName}.fugr.l${objectName}top.abap`, topSource));
+		} catch {}
+		const fixpt = ctx.getData(obj).fixPointArithmetic ? "X" : "";
+		files.push(ctx.createFile(`${objectName}.fugr.l${objectName}top.xml`, buildProgdirXml(`L${nameUpper}TOP`, "I", fixpt)));
+		files.push(ctx.createFile(`${objectName}.fugr.sapl${objectName}.abap`, buildMainProgramSource(nameUpper)), ctx.createFile(`${objectName}.fugr.sapl${objectName}.xml`, buildProgdirXml(`SAPL${nameUpper}`, "F", fixpt)));
+		for (const fm of fmItems) {
+			const funcName = fm.name.toLowerCase();
+			try {
+				const source = await obj.client.adt.functions.groups.fmodules.source.main.get(obj.name, fm.name);
+				if (source) files.push(ctx.createFile(`${objectName}.fugr.${funcName}.abap`, source));
+			} catch {}
+		}
+		return files;
+	},
+	fromAbapGit: ({ AREAT, FUNCTIONS }) => ({
+		name: "",
+		type: "FUGR/F",
+		description: AREAT,
+		language: "EN",
+		masterLanguage: "EN",
+		_functions: FUNCTIONS
+	}),
+	setSources: (obj, sources) => {
+		const name = obj.name.toLowerCase();
+		const topKey = `l${name}top`;
+		const mainSource = sources.main ?? sources[topKey];
+		if (mainSource) obj._pendingSource = mainSource;
+		const fmSources = {};
+		for (const [suffix, content] of Object.entries(sources)) {
+			if (suffix === "main" || suffix === topKey || suffix.startsWith(`l${name}`) || suffix.startsWith(`sapl${name}`)) continue;
+			fmSources[suffix] = content;
+		}
+		if (Object.keys(fmSources).length > 0) obj._pendingFmSources = fmSources;
+	}
+});
+/**
+* Discover child function modules via object structure endpoint.
+* Falls back to empty list if the endpoint is unavailable.
+*/
+async function discoverFunctionModules(obj) {
+	try {
+		const response = await obj.client.adt.functions.groups.objectstructure(obj.name);
+		const responseStr = String(response);
+		const fmNames = [];
+		const regex = /type="FUGR\/FF"[^>]*adtcore:name="([^"]+)"/g;
+		let match;
+		while ((match = regex.exec(responseStr)) !== null) fmNames.push({ name: match[1] });
+		const regex2 = /adtcore:name="([^"]+)"[^>]*type="FUGR\/FF"/g;
+		while ((match = regex2.exec(responseStr)) !== null) if (!fmNames.some((f) => f.name === match[1])) fmNames.push({ name: match[1] });
+		return fmNames;
+	} catch {
+		return [];
+	}
+}
+/**
+* Serialize function module metadata into abapGit FUNCTIONS format.
+* Fetches each FM's metadata via the ADT fmodules contract.
+*/
+async function serializeFunctions(obj, fmItems) {
+	const functions = [];
+	for (const fm of fmItems) try {
+		const fmData = (await obj.client.adt.functions.groups.fmodules.get(obj.name, fm.name))?.abapFunctionModule;
+		if (!fmData) continue;
+		const item = {
+			FUNCNAME: fm.name.toUpperCase(),
+			SHORT_TEXT: fmData.description ?? ""
+		};
+		const remoteCall = processingTypeToRemoteCall(fmData.processingType);
+		if (remoteCall) item.REMOTE_CALL = remoteCall;
+		if (fmData.basXMLEnabled) item.REMOTE_BASXML = "X";
+		functions.push(item);
+	} catch {
+		functions.push({ FUNCNAME: fm.name.toUpperCase() });
+	}
+	return functions;
+}
+function extractFunctionDescriptors(functions) {
+	if (!functions) return [];
+	return (Array.isArray(functions) ? functions : Array.isArray(functions?.item) ? functions.item : functions?.item ? [functions.item] : []).map((fm) => ({
+		funcName: String(fm.FUNCNAME ?? ""),
+		shortText: fm.SHORT_TEXT ? String(fm.SHORT_TEXT) : void 0,
+		processingType: remoteCallToProcessingType(fm.REMOTE_CALL, fm.UPDATE_TASK),
+		basXMLEnabled: fm.REMOTE_BASXML === "X"
+	}));
+}
+/**
+* Build PROGDIR XML for an include program (best-effort defaults).
+* PROGDIR is SAP-internal metadata that abapGit stores but ADT doesn't expose.
+*/
+function buildProgdirXml(programName, subc, fixpt) {
+	return `<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0">
+ <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+   <PROGDIR>
+    <NAME>${programName}</NAME>
+    <SUBC>${subc}</SUBC>${subc === "F" ? "\n    <RLOAD>E</RLOAD>" : ""}
+    <FIXPT>${fixpt}</FIXPT>
+    <UCCHECK>X</UCCHECK>
+   </PROGDIR>
+  </asx:values>
+ </asx:abap>
+</abapGit>
+`;
+}
+/**
+* Build the standard main program source (SAPL{NAME}).
+* This is system-generated and contains INCLUDE declarations.
+*/
+function buildMainProgramSource(nameUpper) {
+	return `*******************************************************************
+*   System-defined Include-files.                                 *
+*******************************************************************
+  INCLUDE L${nameUpper}TOP.                    " Global Declarations
+  INCLUDE L${nameUpper}UXX.                    " Function Modules
+
+*******************************************************************
+*   User-defined Include-files (if necessary).                    *
+*******************************************************************
+* INCLUDE L${nameUpper}F...                    " Subroutines
+* INCLUDE L${nameUpper}O...                    " PBO-Modules
+* INCLUDE L${nameUpper}I...                    " PAI-Modules
+* INCLUDE L${nameUpper}E...                    " Events
+* INCLUDE L${nameUpper}P...                    " Local class implement.
+* INCLUDE L${nameUpper}T99.                    " ABAP Unit tests
+`;
+}
+
+//#endregion
+//#region src/lib/handlers/objects/doma.ts
+/**
+* Domain (DOMA) object handler for abapGit format
+*/
+const domainHandler = createHandler(AdkDomain, {
+	schema: doma,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_DOMA",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const data = obj.dataSync;
+		const typeInfo = data?.content?.typeInformation;
+		const outInfo = data?.content?.outputInformation;
+		const valueInfo = data?.content?.valueInformation;
+		const fixValues = valueInfo?.fixValues?.fixValue;
+		const DD07V_TAB = fixValues && fixValues.length > 0 ? { DD07V: fixValues.map((fv) => {
+			const entry = {
+				DOMNAME: obj.name ?? "",
+				VALPOS: String(fv.position ?? "").padStart(4, "0"),
+				DDLANGUAGE: isoToSapLang(data?.language),
+				DOMVALUE_L: fv.low ?? "",
+				DDTEXT: fv.text ?? ""
+			};
+			if (fv.high) entry.DOMVALUE_H = fv.high;
+			return entry;
+		}) } : void 0;
+		return {
+			DD01V: {
+				DOMNAME: obj.name ?? "",
+				DDLANGUAGE: isoToSapLang(data?.language),
+				DATATYPE: typeInfo?.datatype ?? "",
+				LENG: String(typeInfo?.length ?? "").padStart(6, "0"),
+				DECIMALS: typeInfo?.decimals ? String(typeInfo.decimals).padStart(6, "0") : void 0,
+				OUTPUTLEN: String(outInfo?.length ?? "").padStart(6, "0"),
+				LOWERCASE: outInfo?.lowercase ? "X" : void 0,
+				SIGNFLAG: outInfo?.signExists ? "X" : void 0,
+				CONVEXIT: outInfo?.conversionExit || void 0,
+				ENTITYTAB: valueInfo?.valueTableRef?.name || void 0,
+				VALEXI: fixValues && fixValues.length > 0 ? "X" : void 0,
+				DDTEXT: obj.description ?? "",
+				DOMMASTER: isoToSapLang(obj.masterLanguage)
+			},
+			DD07V_TAB
+		};
+	},
+	fromAbapGit: ({ DD01V, DD07V_TAB }) => {
+		const fixValues = DD07V_TAB?.DD07V?.map((fv, idx) => ({
+			position: Number(fv.VALPOS ?? idx + 1),
+			low: fv.DOMVALUE_L ?? "",
+			high: fv.DOMVALUE_H ?? "",
+			text: fv.DDTEXT ?? ""
+		})) ?? [];
+		return {
+			name: (DD01V?.DOMNAME ?? "").toUpperCase(),
+			type: "DOMA/DD",
+			description: DD01V?.DDTEXT,
+			language: sapLangToIso(DD01V?.DDLANGUAGE),
+			masterLanguage: sapLangToIso(DD01V?.DDLANGUAGE),
+			content: {
+				typeInformation: {
+					datatype: DD01V?.DATATYPE ?? "",
+					length: Number(DD01V?.LENG ?? 0),
+					decimals: Number(DD01V?.DECIMALS ?? 0)
+				},
+				outputInformation: {
+					length: Number(DD01V?.OUTPUTLEN ?? 0),
+					style: "",
+					conversionExit: DD01V?.CONVEXIT || void 0,
+					signExists: DD01V?.SIGNFLAG === "X",
+					lowercase: DD01V?.LOWERCASE === "X"
+				},
+				valueInformation: {
+					valueTableRef: { name: DD01V?.ENTITYTAB || void 0 },
+					fixValues: { fixValue: fixValues.length > 0 ? fixValues : void 0 }
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/dtel.ts
+/**
+* Data Element (DTEL) object handler for abapGit format
+*/
+/**
+* Map ADT typeKind → abapGit REFKIND
+*/
+const TYPEKIND_TO_REFKIND = {
+	domain: "D",
+	predefinedAbapType: "",
+	refToPredefinedAbapType: "R",
+	refToDictionaryType: "R",
+	refToClifType: "R"
+};
+/**
+* Map ADT typeKind → abapGit REFTYPE (only for reference types)
+*/
+const TYPEKIND_TO_REFTYPE = {
+	refToClifType: "C",
+	refToDictionaryType: "E",
+	refToPredefinedAbapType: "E"
+};
+/**
+* Derive OUTPUTLEN from ABAP data type + length + decimals.
+*
+* The ADT REST API for data elements does not return OUTPUTLEN — SAP derives
+* it internally from the type definition. This function replicates SAP's
+* output length calculation for standard ABAP dictionary types.
+*/
+function deriveOutputLength(dataType, length, decimals) {
+	if (!dataType || !length) return void 0;
+	const type = dataType.toUpperCase();
+	const len = length;
+	const dec = decimals ?? 0;
+	switch (type) {
+		case "CHAR":
+		case "NUMC":
+		case "UNIT":
+		case "CUKY":
+		case "LCHR":
+		case "SSTRING": return String(len).padStart(6, "0");
+		case "CLNT": return "000003";
+		case "LANG": return "000001";
+		case "DATS": return "000010";
+		case "TIMS": return "000008";
+		case "INT1": return "000003";
+		case "INT2": return "000005";
+		case "INT4": return "000010";
+		case "INT8": return "000019";
+		case "FLTP": return "000022";
+		case "DEC":
+		case "CURR":
+		case "QUAN": {
+			const intDigits = len - dec;
+			const separators = intDigits > 1 ? Math.floor((intDigits - 1) / 3) : 0;
+			const outputLen = len + 1 + separators;
+			return String(outputLen).padStart(6, "0");
+		}
+		case "RAW":
+		case "LRAW": return String(len * 2).padStart(6, "0");
+		case "STRING":
+		case "RAWSTRING":
+		case "GEOM_EWKB": return;
+		default: return;
+	}
+}
+const dataElementHandler = createHandler(AdkDataElement, {
+	schema: dtel,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_DTEL",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const data = obj.dataSync;
+		const de = data?.dataElement;
+		const typeKind = de?.typeKind ?? "";
+		const isDomain = typeKind === "domain";
+		const dataType = typeKind.startsWith("refTo") ? "REF" : de?.dataType || void 0;
+		const effectiveDataType = isDomain ? void 0 : dataType;
+		const effectiveLeng = isDomain || !de?.dataTypeLength ? void 0 : String(de.dataTypeLength).padStart(6, "0");
+		const effectiveDecimals = isDomain || !de?.dataTypeDecimals ? void 0 : String(de.dataTypeDecimals).padStart(6, "0");
+		const effectiveOutputLen = isDomain ? void 0 : deriveOutputLength(de?.dataType, de?.dataTypeLength, de?.dataTypeDecimals);
+		return { DD04V: {
+			ROLLNAME: obj.name ?? "",
+			DDLANGUAGE: isoToSapLang(obj.language || void 0),
+			DOMNAME: de?.typeName || void 0,
+			HEADLEN: de?.headingFieldLength ? String(de.headingFieldLength) : void 0,
+			SCRLEN1: de?.shortFieldLength ? String(de.shortFieldLength) : void 0,
+			SCRLEN2: de?.mediumFieldLength ? String(de.mediumFieldLength) : void 0,
+			SCRLEN3: de?.longFieldLength ? String(de.longFieldLength) : void 0,
+			DDTEXT: obj.description ?? "",
+			REPTEXT: de?.headingFieldLabel || void 0,
+			SCRTEXT_S: de?.shortFieldLabel || void 0,
+			SCRTEXT_M: de?.mediumFieldLabel || void 0,
+			SCRTEXT_L: de?.longFieldLabel || void 0,
+			DTELMASTER: isoToSapLang(obj.masterLanguage || void 0),
+			DATATYPE: effectiveDataType,
+			LENG: effectiveLeng,
+			DECIMALS: effectiveDecimals,
+			OUTPUTLEN: effectiveOutputLen,
+			REFKIND: TYPEKIND_TO_REFKIND[typeKind] || void 0,
+			REFTYPE: TYPEKIND_TO_REFTYPE[typeKind],
+			ABAP_LANGUAGE_VERSION: abapLangVerFromAdt(data?.abapLanguageVersion)
+		} };
+	},
+	fromAbapGit: ({ DD04V }) => {
+		const refKind = DD04V?.REFKIND ?? "";
+		const refType = DD04V?.REFTYPE ?? "";
+		let typeKind;
+		if (refKind === "D") typeKind = "domain";
+		else if (refKind === "R") typeKind = refType === "C" ? "refToClifType" : "refToDictionaryType";
+		else typeKind = DD04V?.DATATYPE ? "predefinedAbapType" : "domain";
+		return {
+			name: (DD04V?.ROLLNAME ?? "").toUpperCase(),
+			type: "DTEL/DE",
+			description: DD04V?.DDTEXT,
+			language: sapLangToIso(DD04V?.DDLANGUAGE),
+			masterLanguage: sapLangToIso(DD04V?.DDLANGUAGE),
+			abapLanguageVersion: abapLangVerToAdt(DD04V?.ABAP_LANGUAGE_VERSION),
+			dataElement: {
+				typeKind,
+				typeName: DD04V?.DOMNAME || "",
+				dataType: DD04V?.DATATYPE || "",
+				dataTypeLength: DD04V?.LENG ? Number(DD04V.LENG) : 0,
+				dataTypeLengthEnabled: false,
+				dataTypeDecimals: DD04V?.DECIMALS ? Number(DD04V.DECIMALS) : 0,
+				dataTypeDecimalsEnabled: false,
+				shortFieldLabel: DD04V?.SCRTEXT_S || "",
+				shortFieldLength: DD04V?.SCRLEN1 ? Number(DD04V.SCRLEN1) : 0,
+				shortFieldMaxLength: DD04V?.SCRLEN1 ? Number(DD04V.SCRLEN1) : 0,
+				mediumFieldLabel: DD04V?.SCRTEXT_M || "",
+				mediumFieldLength: DD04V?.SCRLEN2 ? Number(DD04V.SCRLEN2) : 0,
+				mediumFieldMaxLength: DD04V?.SCRLEN2 ? Number(DD04V.SCRLEN2) : 0,
+				longFieldLabel: DD04V?.SCRTEXT_L || "",
+				longFieldLength: DD04V?.SCRLEN3 ? Number(DD04V.SCRLEN3) : 0,
+				longFieldMaxLength: DD04V?.SCRLEN3 ? Number(DD04V.SCRLEN3) : 0,
+				headingFieldLabel: DD04V?.REPTEXT || "",
+				headingFieldLength: DD04V?.HEADLEN ? Number(DD04V.HEADLEN) : 0,
+				headingFieldMaxLength: DD04V?.HEADLEN ? Number(DD04V.HEADLEN) : 0,
+				searchHelp: "",
+				searchHelpParameter: "",
+				setGetParameter: "",
+				defaultComponentName: "",
+				deactivateInputHistory: false,
+				changeDocument: false,
+				leftToRightDirection: false,
+				deactivateBIDIFiltering: false,
+				documentationStatus: ""
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/cds-to-abapgit.ts
+/** Extract the string value from an annotation value node */
+function annotationStringValue(val) {
+	switch (val.kind) {
+		case "string": return val.value;
+		case "enum": return val.value;
+		case "boolean": return val.value ? "X" : "";
+		case "number": return String(val.value);
+		default: return "";
+	}
+}
+/** Find annotation by key and return its string value */
+function getAnnotation(annotations, key) {
+	const ann = annotations.find((a) => a.key === key);
+	return ann ? annotationStringValue(ann.value) : void 0;
+}
+const TABLE_CATEGORY_MAP = {
+	TRANSPARENT: "TRANSP",
+	CLUSTER: "CLUSTER",
+	POOL: "POOL",
+	APPEND: "APPEND"
+};
+const ENHANCEMENT_CATEGORY_MAP = {
+	NOT_EXTENSIBLE: "1",
+	EXTENSIBLE_CHARACTER_NUMERIC: "2",
+	EXTENSIBLE_CHARACTER: "3",
+	EXTENSIBLE_ANY: "4",
+	NOT_CLASSIFIED: "0"
+};
+const DATA_MAINTENANCE_MAP = {
+	RESTRICTED: "X",
+	NOT_ALLOWED: "N",
+	ALLOWED: ""
+};
+/**
+* Build DD02V data from a parsed CDS table/structure definition
+*/
+function buildDD02V(def, language, description) {
+	let tabclass = def.kind === "structure" ? "INTTAB" : "TRANSP";
+	const tableCategory = getAnnotation(def.annotations, "AbapCatalog.tableCategory");
+	if (tableCategory) tabclass = TABLE_CATEGORY_MAP[tableCategory] || tabclass;
+	const deliveryClass = getAnnotation(def.annotations, "AbapCatalog.deliveryClass");
+	const enhancementCategory = getAnnotation(def.annotations, "AbapCatalog.enhancement.category");
+	const dataMaintenance = getAnnotation(def.annotations, "AbapCatalog.dataMaintenance");
+	const hasLanguageField = def.members.some((m) => {
+		if ("kind" in m && m.kind === "include") return false;
+		const f = m;
+		if (f.type.kind === "named") return f.type.name.toUpperCase() === "SPRAS";
+		if (f.type.kind === "builtin") return f.type.name === "lang";
+		return false;
+	});
+	const hasClientKeyField = def.members.some((m) => {
+		if ("kind" in m && m.kind === "include") return false;
+		const f = m;
+		if (!f.isKey) return false;
+		if (f.type.kind === "named") return f.type.name.toUpperCase() === "MANDT";
+		if (f.type.kind === "builtin") return f.type.name === "clnt";
+		return false;
+	});
+	const result = {};
+	result.TABNAME = def.name.toUpperCase();
+	result.DDLANGUAGE = language;
+	result.TABCLASS = tabclass;
+	if (hasLanguageField) result.LANGDEP = "X";
+	if (hasClientKeyField) result.CLIDEP = "X";
+	result.DDTEXT = description;
+	result.MASTERLANG = language;
+	if (deliveryClass) result.CONTFLAG = deliveryClass;
+	if (enhancementCategory) result.EXCLASS = ENHANCEMENT_CATEGORY_MAP[enhancementCategory];
+	if (dataMaintenance) result.MATEFLAG = DATA_MAINTENANCE_MAP[dataMaintenance] ?? "";
+	return result;
+}
+const BUILTIN_TYPES = {
+	char: {
+		datatype: "CHAR",
+		inttype: "C"
+	},
+	clnt: {
+		datatype: "CLNT",
+		inttype: "C",
+		length: 3
+	},
+	numc: {
+		datatype: "NUMC",
+		inttype: "N"
+	},
+	dats: {
+		datatype: "DATS",
+		inttype: "D",
+		length: 8,
+		fixedIntlen: 16,
+		shlporigin: "T"
+	},
+	datn: {
+		datatype: "DATN",
+		inttype: "D",
+		length: 8,
+		fixedIntlen: 16,
+		shlporigin: "T"
+	},
+	tims: {
+		datatype: "TIMS",
+		inttype: "T",
+		length: 6,
+		fixedIntlen: 12,
+		shlporigin: "T"
+	},
+	timn: {
+		datatype: "TIMN",
+		inttype: "T",
+		length: 6,
+		fixedIntlen: 12,
+		shlporigin: "T"
+	},
+	string: {
+		datatype: "STRG",
+		inttype: "g",
+		fixedIntlen: 8,
+		noLeng: true
+	},
+	xstring: {
+		datatype: "RSTR",
+		inttype: "y",
+		fixedIntlen: 8,
+		noLeng: true
+	},
+	int1: {
+		datatype: "INT1",
+		inttype: "X",
+		length: 3,
+		fixedIntlen: 1
+	},
+	int2: {
+		datatype: "INT2",
+		inttype: "X",
+		length: 5,
+		fixedIntlen: 2
+	},
+	int4: {
+		datatype: "INT4",
+		inttype: "X",
+		length: 10,
+		fixedIntlen: 4
+	},
+	int8: {
+		datatype: "INT8",
+		inttype: "8",
+		length: 19,
+		fixedIntlen: 8
+	},
+	fltp: {
+		datatype: "FLTP",
+		inttype: "F",
+		length: 16,
+		decimals: 16,
+		fixedIntlen: 8
+	},
+	dec: {
+		datatype: "DEC",
+		inttype: "P"
+	},
+	curr: {
+		datatype: "CURR",
+		inttype: "P"
+	},
+	quan: {
+		datatype: "QUAN",
+		inttype: "P"
+	},
+	raw: {
+		datatype: "RAW",
+		inttype: "X"
+	},
+	rawstring: {
+		datatype: "RSTR",
+		inttype: "y",
+		fixedIntlen: 8,
+		noLeng: true
+	},
+	lang: {
+		datatype: "LANG",
+		inttype: "C",
+		length: 1
+	},
+	unit: {
+		datatype: "UNIT",
+		inttype: "C",
+		length: 3
+	},
+	cuky: {
+		datatype: "CUKY",
+		inttype: "C",
+		length: 5
+	},
+	d16n: {
+		datatype: "D16N",
+		inttype: "a",
+		fixedIntlen: 8
+	},
+	d34n: {
+		datatype: "D34N",
+		inttype: "e",
+		fixedIntlen: 16
+	},
+	utclong: {
+		datatype: "UTCL",
+		inttype: "p",
+		length: 27,
+		fixedIntlen: 8
+	}
+};
+/** Zero-pad number to given width */
+function zeroPad(n, width) {
+	return String(n).padStart(width, "0");
+}
+/** Compute internal length from type info */
+function computeIntlen(builtin, length) {
+	if (builtin.fixedIntlen !== void 0) return builtin.fixedIntlen;
+	if (builtin.inttype === "P" && length !== void 0) return Math.ceil((length + 1) / 2);
+	if (builtin.inttype === "X" && length !== void 0) return length;
+	if (length !== void 0) return length * 2;
+	if (builtin.length !== void 0) return builtin.length * 2;
+	return 0;
+}
+/** Build a DD03P entry from a single field definition */
+async function buildFieldDD03P(field, tableName, resolver) {
+	const isKey = field.isKey;
+	const notNull = field.notNull;
+	let rollname;
+	let comptype;
+	let inttype;
+	let intlen;
+	let datatype;
+	let leng;
+	let decimals;
+	let mask;
+	let shlporigin;
+	let reftable;
+	let reffield;
+	if (field.type.kind === "builtin") {
+		const bt = field.type;
+		const typeInfo = BUILTIN_TYPES[bt.name];
+		if (typeInfo) {
+			const length = bt.length ?? typeInfo.length;
+			inttype = typeInfo.inttype;
+			intlen = zeroPad(computeIntlen(typeInfo, length), 6);
+			datatype = typeInfo.datatype;
+			if (!typeInfo.noLeng && length !== void 0) leng = zeroPad(length, 6);
+			const dec = bt.decimals ?? typeInfo.decimals;
+			if (dec !== void 0) decimals = zeroPad(dec, 6);
+			mask = `  ${typeInfo.datatype}`;
+			if (typeInfo.shlporigin) shlporigin = typeInfo.shlporigin;
+			if (bt.name === "curr" || bt.name === "quan") {
+				const refAnnotation = getAnnotation(field.annotations, bt.name === "curr" ? "Semantics.amount.currencyCode" : "Semantics.quantity.unitOfMeasure");
+				if (refAnnotation) {
+					reftable = tableName;
+					const parts = refAnnotation.split(".");
+					reffield = parts[parts.length - 1].toUpperCase();
+				}
+			}
+		}
+	} else {
+		rollname = field.type.name.toUpperCase();
+		comptype = "E";
+		if (resolver) {
+			const resolved = await resolver.resolve(field.type.name);
+			comptype = resolved.comptype;
+			if (resolved.shlporigin) shlporigin = resolved.shlporigin;
+			if (resolved.comptype === "S") {
+				datatype = "STRU";
+				mask = "  STRUS";
+			}
+		}
+	}
+	const result = {};
+	result.FIELDNAME = field.name.toUpperCase();
+	if (isKey) result.KEYFLAG = "X";
+	if (rollname) result.ROLLNAME = rollname;
+	result.ADMINFIELD = "0";
+	if (inttype) result.INTTYPE = inttype;
+	if (intlen) result.INTLEN = intlen;
+	if (notNull) result.NOTNULL = "X";
+	if (datatype) result.DATATYPE = datatype;
+	if (leng) result.LENG = leng;
+	if (decimals) result.DECIMALS = decimals;
+	if (shlporigin) result.SHLPORIGIN = shlporigin;
+	if (reftable) result.REFTABLE = reftable;
+	if (reffield) result.REFFIELD = reffield;
+	if (mask) result.MASK = mask;
+	if (comptype) result.COMPTYPE = comptype;
+	return result;
+}
+/**
+* Build DD03P entries from table/structure members
+*/
+async function buildDD03P(members, tableName = "", resolver) {
+	const entries = [];
+	for (const member of members) if ("kind" in member && member.kind === "include") {
+		const inc = member;
+		const includeName = inc.name.toUpperCase();
+		let ddtext;
+		if (resolver) ddtext = (await resolver.resolve(inc.name)).description;
+		if (inc.suffix) {
+			const entry = {
+				FIELDNAME: `.INCLU-${inc.suffix.toUpperCase()}`,
+				ADMINFIELD: "0",
+				PRECFIELD: includeName,
+				MASK: "      S",
+				COMPTYPE: "S"
+			};
+			if (ddtext) entry.DDTEXT = ddtext;
+			entries.push(entry);
+		} else {
+			const entry = {
+				FIELDNAME: ".INCLUDE",
+				ADMINFIELD: "0",
+				PRECFIELD: includeName,
+				MASK: "      S",
+				COMPTYPE: "S"
+			};
+			if (ddtext) entry.DDTEXT = ddtext;
+			entries.push(entry);
+		}
+	} else {
+		const field = member;
+		entries.push(await buildFieldDD03P(field, tableName, resolver));
+	}
+	return entries;
+}
+
+//#endregion
+//#region src/lib/handlers/objects/tabl.ts
+/**
+* Table/Structure (TABL) object handlers for abapGit format
+*
+* Serializes SAP tables (TABL/DT) and structures (TABL/DS) to
+* abapGit-compatible XML format by fetching the CDS-style source code
+* from SAP, parsing it with @abapify/acds, and mapping the AST into
+* DD02V/DD03P structures.
+*
+* Tables and structures share the same serialization logic but use
+* different ADT endpoints (ddic/tables vs ddic/structures).
+*
+* Data sources:
+* - blueSource GET: name, type, description, language
+* - source/main GET: CDS source with annotations and field definitions
+*   → parsed via @abapify/acds into AST
+*   → mapped into DD02V annotations and DD03P field entries
+* - Per named type: /sap/bc/adt/ddic/dataelements/{name} or /structures/{name}
+*   → resolves COMPTYPE (E vs S), SHLPORIGIN, description (DDTEXT)
+*/
+/**
+* Strip undefined/empty-string values from an object
+* to avoid emitting empty XML elements
+*/
+function stripEmpty(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== "") result[key] = value;
+	return result;
+}
+/**
+* Create a TypeResolver that resolves named types via ADT endpoints.
+* Tries data element first, then structure. Caches results.
+*/
+function createAdtTypeResolver(obj) {
+	const cache = /* @__PURE__ */ new Map();
+	return { async resolve(name) {
+		const key = name.toLowerCase();
+		if (cache.has(key)) return cache.get(key);
+		const dtelXml = await obj.fetchText(`/sap/bc/adt/ddic/dataelements/${encodeURIComponent(key)}`);
+		if (dtelXml) {
+			const result = { comptype: "E" };
+			if (dtelXml.match(/<dtel:searchHelp>[^<]+<\/dtel:searchHelp>/)) result.shlporigin = "D";
+			const descMatch = dtelXml.match(/adtcore:description="([^"]+)"/);
+			if (descMatch) result.description = descMatch[1];
+			cache.set(key, result);
+			return result;
+		}
+		const structXml = await obj.fetchText(`/sap/bc/adt/ddic/structures/${encodeURIComponent(key)}`);
+		if (structXml) {
+			const result = { comptype: "S" };
+			const descMatch = structXml.match(/adtcore:description="([^"]+)"/);
+			if (descMatch) result.description = descMatch[1];
+			cache.set(key, result);
+			return result;
+		}
+		const fallback = { comptype: "E" };
+		cache.set(key, fallback);
+		return fallback;
+	} };
+}
+/**
+* Parse ADT table settings XML into DD09L data for abapGit serialization.
+*
+* Uses the typed `tablesettings` schema from @abapify/adt-schemas to parse
+* the ADT endpoint response (/sap/bc/adt/ddic/db/settings/{name}).
+*
+* Mapping:
+*   tableSettings.sizeCategory       → DD09L.TABKAT
+*   tableSettings.dataClassCategory  → DD09L.TABART
+*   tableSettings.buffering.allowed  → DD09L.BUFALLOW
+*   tableSettings.buffering.type     → DD09L.PUFFERUNG
+*   tableSettings.buffering.areaKeyFields → DD09L.SCHFELDANZ
+*   tableSettings.loggingEnabled     → DD09L.PROTOKOLL
+*/
+function parseSettingsToDD09L(settingsXml, tableName) {
+	let settings;
+	try {
+		const parsed = tablesettings.parse(settingsXml);
+		if (!("tableSettings" in parsed)) return void 0;
+		settings = parsed.tableSettings;
+	} catch {
+		return;
+	}
+	const dd09l = {};
+	dd09l.TABNAME = tableName;
+	dd09l.AS4LOCAL = "A";
+	if (settings.sizeCategory) dd09l.TABKAT = settings.sizeCategory;
+	if (settings.dataClassCategory) dd09l.TABART = settings.dataClassCategory;
+	if (settings.buffering?.allowed) dd09l.BUFALLOW = settings.buffering.allowed;
+	const bufType = settings.buffering?.type;
+	if (bufType) dd09l.PUFFERUNG = bufType;
+	const areaKeyFields = settings.buffering?.areaKeyFields;
+	if (areaKeyFields && areaKeyFields !== "0") dd09l.SCHFELDANZ = areaKeyFields;
+	if (settings.loggingEnabled) dd09l.PROTOKOLL = "X";
+	return dd09l;
+}
+/**
+* Shared serialize logic for tables and structures.
+* Both use CDS source → DD02V/DD03P mapping.
+*/
+async function serializeTabl(obj, ctx) {
+	const objectName = ctx.getObjectName(obj);
+	const lang = isoToSapLang(obj.language || void 0);
+	let cdsSource;
+	try {
+		cdsSource = await obj.getSource();
+	} catch {
+		const xmlContent = ctx.toAbapGitXml(obj);
+		return [ctx.createFile(`${objectName}.tabl.xml`, xmlContent)];
+	}
+	const { ast, errors } = parse(cdsSource);
+	if (errors.length > 0 || ast.definitions.length === 0) {
+		const xmlContent = ctx.toAbapGitXml(obj);
+		return [ctx.createFile(`${objectName}.tabl.xml`, xmlContent)];
+	}
+	const def = ast.definitions[0];
+	const dd02v = buildDD02V(def, lang, obj.description ?? "");
+	const resolver = createAdtTypeResolver(obj);
+	const dd03pEntries = await buildDD03P(def.members, def.name.toUpperCase(), resolver);
+	const values = { DD02V: stripEmpty(dd02v) };
+	if ("getSettings" in obj && typeof obj.getSettings === "function") try {
+		const settingsXml = await obj.getSettings();
+		if (settingsXml) {
+			const dd09l = parseSettingsToDD09L(settingsXml, def.name.toUpperCase());
+			if (dd09l) values.DD09L = stripEmpty(dd09l);
+		}
+	} catch {}
+	if (dd03pEntries.length > 0) values.DD03P_TABLE = { DD03P: dd03pEntries.map((entry) => stripEmpty(entry)) };
+	const fullPayload = {
+		abap: {
+			version: "1.0",
+			values
+		},
+		version: "v1.0.0",
+		serializer: "LCL_OBJECT_TABL",
+		serializer_version: "v1.0.0"
+	};
+	const xml = formatAbapGitXml(tabl.build(fullPayload, { pretty: true }));
+	return [ctx.createFile(`${objectName}.tabl.xml`, xml)];
+}
+/** Shared fromAbapGit logic for both tables and structures */
+function fromAbapGitTabl({ DD02V } = {}) {
+	return {
+		name: (DD02V?.TABNAME ?? "").toUpperCase(),
+		type: DD02V?.TABCLASS === "INTTAB" ? "TABL/DS" : "TABL/DT",
+		description: DD02V?.DDTEXT,
+		language: sapLangToIso(DD02V?.DDLANGUAGE),
+		masterLanguage: sapLangToIso(DD02V?.DDLANGUAGE)
+	};
+}
+const tableHandler = createHandler(AdkTable, {
+	schema: tabl,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_TABL",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ DD02V: {
+		TABNAME: obj.name ?? "",
+		DDLANGUAGE: isoToSapLang(obj.language || void 0),
+		TABCLASS: "TRANSP",
+		DDTEXT: obj.description ?? ""
+	} }),
+	serialize: (obj, ctx) => serializeTabl(obj, ctx),
+	fromAbapGit: fromAbapGitTabl
+});
+const structureHandler = createHandler(AdkStructure, {
+	schema: tabl,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_TABL",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ DD02V: {
+		TABNAME: obj.name ?? "",
+		DDLANGUAGE: isoToSapLang(obj.language || void 0),
+		TABCLASS: "INTTAB",
+		DDTEXT: obj.description ?? ""
+	} }),
+	serialize: (obj, ctx) => serializeTabl(obj, ctx),
+	fromAbapGit: fromAbapGitTabl
+});
+
+//#endregion
+//#region src/lib/handlers/objects/ttyp.ts
+/**
+* Table Type (TTYP) object handler for abapGit format
+*
+* Maps between abapGit DD40V codes and ADT API enum values.
+*/
+/** DD40V ACCESSMODE → ADT accessType */
+const ACCESS_MODE_TO_ADT = {
+	T: "standard",
+	S: "sorted",
+	H: "hashed"
+};
+const ACCESS_MODE_FROM_ADT = Object.fromEntries(Object.entries(ACCESS_MODE_TO_ADT).map(([k, v]) => [v, k]));
+/** DD40V KEYDEF → ADT primaryKey.definition */
+const KEY_DEF_TO_ADT = {
+	D: "standard",
+	K: "keyComponents",
+	T: "rowType"
+};
+const KEY_DEF_FROM_ADT = Object.fromEntries(Object.entries(KEY_DEF_TO_ADT).map(([k, v]) => [v, k]));
+/** DD40V KEYKIND → ADT primaryKey.kind */
+const KEY_KIND_TO_ADT = {
+	N: "nonUnique",
+	U: "unique",
+	G: "notSpecified"
+};
+const KEY_KIND_FROM_ADT = Object.fromEntries(Object.entries(KEY_KIND_TO_ADT).map(([k, v]) => [v, k]));
+/**
+* DD40V ROWKIND → ADT rowType.typeKind
+*
+* ROWKIND='' (empty) + DATATYPE set → predefinedAbapType (built-in like STRING, INT4)
+* ROWKIND='S' → dictionaryType (references a structure/table/data element)
+* ROWKIND='R' → ref type
+*/
+const ROW_KIND_TO_ADT = {
+	"": "predefinedAbapType",
+	S: "dictionaryType",
+	R: "refToDictionaryType"
+};
+const ROW_KIND_FROM_ADT = Object.fromEntries(Object.entries(ROW_KIND_TO_ADT).map(([k, v]) => [v, k]));
+/**
+* DD40V DATATYPE (DDIC code) → ADT builtInType.dataType (ABAP type name)
+*
+* abapGit stores 4-char DDIC internal codes (e.g. STRG, RSTR).
+* SAP ADT REST API uses ABAP type names (e.g. STRING, XSTRING).
+* Most types use the same name in both (CHAR, NUMC, INT4, etc.);
+* only a few differ.
+*/
+const DATATYPE_TO_ADT = {
+	STRG: "STRING",
+	SSTR: "SSTRING",
+	RSTR: "XSTRING",
+	UTCL: "UTCLONG"
+};
+const DATATYPE_FROM_ADT = Object.fromEntries(Object.entries(DATATYPE_TO_ADT).map(([k, v]) => [v, k]));
+/**
+* DD40V TYPELEN — fixed internal byte length for predefined types.
+*
+* Variable-length types (STRING, XSTRING) have a fixed pointer size (8 bytes)
+* that abapGit stores as TYPELEN. This is not the same as LENG (display length).
+* We only need to emit TYPELEN for types that have noLeng=true (no external LENG).
+*/
+const FIXED_TYPELEN = {
+	STRG: 8,
+	RSTR: 8
+};
+const tableTypeHandler = createHandler(AdkTableType, {
+	schema: ttyp,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_TTYP",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const data = obj.dataSync;
+		const accessMode = ACCESS_MODE_FROM_ADT[data?.accessType ?? ""] ?? data?.accessType ?? "";
+		const keyDef = KEY_DEF_FROM_ADT[data?.primaryKey?.definition ?? ""] ?? data?.primaryKey?.definition ?? "";
+		const keyKind = KEY_KIND_FROM_ADT[data?.primaryKey?.kind ?? ""] ?? data?.primaryKey?.kind ?? "";
+		const rowKind = ROW_KIND_FROM_ADT[data?.rowType?.typeKind ?? ""] ?? data?.rowType?.typeKind ?? "";
+		const adtDataType = data?.rowType?.builtInType?.dataType ?? "";
+		const ddicDataType = DATATYPE_FROM_ADT[adtDataType] ?? adtDataType;
+		const typeLen = FIXED_TYPELEN[ddicDataType];
+		return { DD40V: {
+			TYPENAME: obj.name ?? "",
+			DDLANGUAGE: isoToSapLang(data?.language || void 0),
+			ROWTYPE: data?.rowType?.typeName || void 0,
+			ROWKIND: rowKind || void 0,
+			DATATYPE: ddicDataType,
+			LENG: data?.rowType?.builtInType?.length ? String(data.rowType.builtInType.length).padStart(6, "0") : void 0,
+			DECIMALS: data?.rowType?.builtInType?.decimals ? String(data.rowType.builtInType.decimals).padStart(6, "0") : void 0,
+			ACCESSMODE: accessMode,
+			KEYDEF: keyDef,
+			KEYKIND: keyKind,
+			DDTEXT: obj.description ?? "",
+			TYPELEN: typeLen ? String(typeLen).padStart(6, "0") : void 0,
+			ABAP_LANGUAGE_VERSION: abapLangVerFromAdt(data?.abapLanguageVersion)
+		} };
+	},
+	fromAbapGit: ({ DD40V }) => {
+		const accessType = ACCESS_MODE_TO_ADT[DD40V?.ACCESSMODE ?? ""] ?? DD40V?.ACCESSMODE;
+		const keyDef = KEY_DEF_TO_ADT[DD40V?.KEYDEF ?? ""] ?? DD40V?.KEYDEF;
+		const keyKind = KEY_KIND_TO_ADT[DD40V?.KEYKIND ?? ""] ?? DD40V?.KEYKIND;
+		const rowKind = ROW_KIND_TO_ADT[DD40V?.ROWKIND ?? ""] ?? DD40V?.ROWKIND;
+		const ddicCode = DD40V?.DATATYPE ?? "";
+		const adtDataType = DATATYPE_TO_ADT[ddicCode] ?? ddicCode;
+		const isPredefined = rowKind === "predefinedAbapType";
+		return {
+			name: (DD40V?.TYPENAME ?? "").toUpperCase(),
+			type: "TTYP/DA",
+			description: DD40V?.DDTEXT,
+			language: sapLangToIso(DD40V?.DDLANGUAGE),
+			masterLanguage: sapLangToIso(DD40V?.DDLANGUAGE),
+			abapLanguageVersion: abapLangVerToAdt(DD40V?.ABAP_LANGUAGE_VERSION),
+			rowType: {
+				typeKind: rowKind,
+				typeName: isPredefined ? "" : DD40V?.ROWTYPE || "",
+				builtInType: {
+					dataType: ddicCode ? adtDataType : "",
+					length: DD40V?.LENG ? Number(DD40V.LENG) : 0,
+					decimals: DD40V?.DECIMALS ? Number(DD40V.DECIMALS) : 0
+				},
+				rangeType: ""
+			},
+			accessType,
+			primaryKey: {
+				definition: keyDef,
+				kind: keyKind,
+				components: { component: [] },
+				alias: ""
+			},
+			secondaryKeys: { allowed: "notSpecified" }
+		};
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/bdef.ts
+/**
+* BDEF (RAP Behavior Definition) object handler for abapGit format
+*
+* BDEF is source-driven: the semantic content lives in a `.abdl` file
+* (the RAP behavior definition language) and abapGit stores it alongside
+* a minimal SKEY metadata block.
+*
+* File layout:
+*   src/zbp_foo.bdef.abdl   — behavior source (.abdl text)
+*   src/zbp_foo.bdef.xml    — minimal metadata wrapper
+*
+* The handler uses the string form of `createHandler` ('BDEF') because
+* the ADK object (`AdkBehaviorDefinition`) is a lightweight class without
+* the AdkObject save/lock machinery — all lifecycle is source-based.
+*
+* We override `serialize` so the source file gets the `.abdl` extension
+* instead of the default `.abap`.
+*/
+const behaviorDefinitionHandler = createHandler("BDEF", {
+	schema: bdef,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_BDEF",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ SKEY: {
+		TYPE: "BDEF",
+		NAME: String(obj?.name ?? "").toUpperCase()
+	} }),
+	getSource: (obj) => typeof obj?.getSource === "function" ? obj.getSource() : Promise.resolve(""),
+	fromAbapGit: ({ SKEY }) => ({ name: String(SKEY?.NAME ?? "").toUpperCase() }),
+	async serialize(object, ctx) {
+		const files = [];
+		const objectName = ctx.getObjectName(object);
+		const source = await (typeof object?.getSource === "function" ? object.getSource() : Promise.resolve(""));
+		if (source) files.push(ctx.createFile(`${objectName}.${ctx.fileExtension}.abdl`, source));
+		const xmlContent = ctx.toAbapGitXml(object);
+		files.push(ctx.createFile(`${objectName}.${ctx.fileExtension}.xml`, xmlContent));
+		return files;
+	},
+	setSources: (obj, sources) => {
+		if (sources.main) obj._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/srvd.ts
+/**
+* SRVD (RAP Service Definition) object handler for abapGit format
+*
+* SRVD is source-driven: the semantic content lives in a `.asrvd` file
+* (CDS-like service definition) and abapGit stores it alongside
+* a minimal SKEY metadata block.
+*
+* File layout:
+*   src/zui_foo.srvd.asrvd   — service source (.asrvd text)
+*   src/zui_foo.srvd.xml     — minimal metadata wrapper
+*
+* The handler uses the string form of `createHandler` ('SRVD') because
+* the ADK object (`AdkServiceDefinition`) is a lightweight class without
+* the AdkObject save/lock machinery — all lifecycle is source-based.
+*
+* We override `serialize` so the source file gets the `.asrvd` extension
+* instead of the default `.abap`.
+*/
+const serviceDefinitionHandler = createHandler("SRVD", {
+	schema: srvd,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_SRVD",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ SKEY: {
+		TYPE: "SRVD",
+		NAME: String(obj?.name ?? "").toUpperCase()
+	} }),
+	getSource: (obj) => typeof obj?.getSource === "function" ? obj.getSource() : Promise.resolve(""),
+	fromAbapGit: ({ SKEY }) => ({ name: String(SKEY?.NAME ?? "").toUpperCase() }),
+	async serialize(object, ctx) {
+		const files = [];
+		const objectName = ctx.getObjectName(object);
+		const source = await (typeof object?.getSource === "function" ? object.getSource() : Promise.resolve(""));
+		if (source) files.push(ctx.createFile(`${objectName}.${ctx.fileExtension}.asrvd`, source));
+		const xmlContent = ctx.toAbapGitXml(object);
+		files.push(ctx.createFile(`${objectName}.${ctx.fileExtension}.xml`, xmlContent));
+		return files;
+	},
+	setSources: (obj, sources) => {
+		if (sources.main) obj._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/srvb.ts
+/**
+* SRVB (RAP Service Binding) object handler for abapGit format
+*
+* Unlike BDEF/SRVD, SRVB is **metadata-only** — there is no `.abdl`/
+* `.asrvd`-style source text. The handler writes a single
+* `<name>.srvb.xml` file carrying a minimal SKEY + BINDING block.
+*
+* File layout:
+*   src/zui_foo.srvb.xml     — metadata only
+*
+* Mirrors the minimal-block approach used by
+* zcl_abapgit_object_srvb (abapGit upstream serialiser).
+*/
+const serviceBindingHandler = createHandler("SRVB", {
+	schema: srvb,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_SRVB",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({
+		SKEY: {
+			TYPE: "SRVB",
+			NAME: String(obj?.name ?? "").toUpperCase()
+		},
+		BINDING: {
+			TYPE: "odataV4",
+			VERSION: "4",
+			CATEGORY: "odata_v4_ui"
+		}
+	}),
+	fromAbapGit: ({ SKEY }) => ({ name: String(SKEY?.NAME ?? "").toUpperCase() }),
+	async serialize(object, ctx) {
+		const objectName = ctx.getObjectName(object);
+		const xmlContent = ctx.toAbapGitXml(object);
+		return [ctx.createFile(`${objectName}.${ctx.fileExtension}.xml`, xmlContent)];
+	}
+});
+
+//#endregion
+//#region src/lib/folder-logic.ts
+function stripSlashes(s) {
+	let start = 0;
+	let end = s.length;
+	while (start < end && s[start] === "/") start++;
+	while (end > start && s[end - 1] === "/") end--;
+	return s.slice(start, end);
+}
+/**
+* Parse FOLDER_LOGIC from .abapgit.xml content
+*/
+function parseFolderLogicFromAbapGitXml(xmlContent) {
+	const match = /<FOLDER_LOGIC>([^<]+)<\/FOLDER_LOGIC>/i.exec(xmlContent);
+	if (!match) return;
+	const normalized = match[1].trim().toUpperCase();
+	if (normalized === "PREFIX") return "prefix";
+	if (normalized === "FULL") return "full";
+}
+/**
+* Parse STARTING_FOLDER from .abapgit.xml content
+*/
+function parseStartingFolderFromAbapGitXml(xmlContent) {
+	const match = /<STARTING_FOLDER>([^<]+)<\/STARTING_FOLDER>/i.exec(xmlContent);
+	return match ? match[1].trim() : void 0;
+}
+/**
+* Parse abapGit repository metadata from .abapgit.xml content
+*/
+function parseAbapGitMetadata(xmlContent) {
+	return {
+		folderLogic: parseFolderLogicFromAbapGitXml(xmlContent) ?? "prefix",
+		startingFolder: parseStartingFolderFromAbapGitXml(xmlContent) ?? "/src/"
+	};
+}
+/**
+* Reverse of calculatePackageDir — compute SAP package name from directory path
+*
+* Given a directory path relative to the starting folder, the folder logic,
+* and the root package name, compute the SAP package name.
+*
+* PREFIX mode: root 'ZABAPGIT_EXAMPLES' + dir 'clas' → 'ZABAPGIT_EXAMPLES_CLAS'
+* FULL mode: dir 'zabapgit_examples_clas' → 'ZABAPGIT_EXAMPLES_CLAS'
+*
+* @param dirPath - Directory path relative to starting folder
+* @param folderLogic - Folder logic mode (prefix or full)
+* @param rootPackage - Root SAP package name
+* @returns SAP package name
+*/
+function resolvePackageFromDir(dirPath, folderLogic, rootPackage) {
+	if (!dirPath || dirPath === "." || dirPath === "/") return rootPackage;
+	const normalized = stripSlashes(dirPath);
+	if (!normalized) return rootPackage;
+	const parts = normalized.split("/").filter(Boolean);
+	if (parts.length === 0) return rootPackage;
+	switch (folderLogic) {
+		case "prefix": {
+			let pkg = rootPackage;
+			for (const part of parts) pkg = pkg + "_" + part.toUpperCase();
+			return pkg;
+		}
+		case "full":
+		case "full-with-root": return parts.at(-1).toUpperCase();
+		default: return rootPackage;
+	}
+}
+/**
+* Reverse of resolvePackageFromDir — given a SAP package name and the
+* relative directory of an object, back-derive the root package.
+*
+* PREFIX mode: sapPackage 'ZABAPGIT_EXAMPLES_FUGR' + dir 'fugr' → 'ZABAPGIT_EXAMPLES'
+* FULL mode: cannot derive root (returns undefined)
+*
+* @param sapPackage - Actual SAP package name (from GET response)
+* @param relDir - Directory path relative to starting folder
+* @param folderLogic - Folder logic mode
+* @returns Root package name, or undefined if it cannot be derived
+*/
+function reverseResolveRootPackage(sapPackage, relDir, folderLogic) {
+	if (!relDir || relDir === "." || relDir === "/") return sapPackage;
+	const normalized = stripSlashes(relDir);
+	if (!normalized) return sapPackage;
+	const parts = normalized.split("/").filter(Boolean);
+	if (parts.length === 0) return sapPackage;
+	switch (folderLogic) {
+		case "prefix": {
+			const suffix = "_" + parts.map((p) => p.toUpperCase()).join("_");
+			if (sapPackage.toUpperCase().endsWith(suffix)) return sapPackage.slice(0, -suffix.length);
+			return;
+		}
+		case "full":
+		case "full-with-root": return;
+		default: return;
+	}
+}
+/**
+* Parse folder logic from a string value (CLI option or config)
+*/
+function parseFolderLogic(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "prefix" || normalized === "full" || normalized === "full-with-root") return normalized;
+}
+/**
+* Calculate package directory based on folder logic (for import/serialization)
+*
+* @param packagePath - Full package hierarchy from root to current
+* @param folderLogic - Folder logic mode
+* @returns Package directory relative to src/
+*/
+function calculatePackageDir(packagePath, folderLogic) {
+	if (packagePath.length === 0) return "";
+	switch (folderLogic) {
+		case "prefix": {
+			if (packagePath.length === 1) return "";
+			const parts = [];
+			for (let i = 1; i < packagePath.length; i++) {
+				const fullName = packagePath[i];
+				const prefix = packagePath[i - 1] + "_";
+				const relativeName = fullName.startsWith(prefix) ? fullName.slice(prefix.length) : fullName;
+				parts.push(relativeName.toLowerCase());
+			}
+			return parts.join("/");
+		}
+		case "full": return packagePath.map((p) => p.toLowerCase()).join("/");
+		case "full-with-root": return packagePath.map((p) => p.toLowerCase()).join("/");
+		default: return "";
+	}
+}
+/**
+* Generate .abapgit.xml repository metadata file
+*/
+function generateAbapGitXml(folderLogic) {
+	return `<?xml version="1.0" encoding="utf-8"?>
+<asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+ <asx:values>
+  <DATA>
+   <MASTER_LANGUAGE>E</MASTER_LANGUAGE>
+   <STARTING_FOLDER>/src/</STARTING_FOLDER>
+   <FOLDER_LOGIC>${folderLogic === "prefix" ? "PREFIX" : "FULL"}</FOLDER_LOGIC>
+  </DATA>
+ </asx:values>
+</asx:abap>
+`;
+}
+
+//#endregion
+//#region src/lib/deserializer.ts
+/**
+* abapGit file naming convention:
+* - XML metadata: {name}.{type}.xml (e.g., zcl_myclass.clas.xml)
+* - Source code: {name}.{type}.abap (e.g., zcl_myclass.clas.abap)
+* - Source includes: {name}.{type}.{suffix}.abap (e.g., zcl_myclass.clas.testclasses.abap)
+*/
+/**
+* Parse abapGit filename to extract object info
+*/
+function parseAbapGitFilename(filename) {
+	const match = filename.match(/^([^.]+)\.([^.]+)(?:\.([^.]+))?\.(\w+)$/);
+	if (!match) return null;
+	const [, name, type, suffixOrExt, extension] = match;
+	if (extension === "xml" || extension === "abap") return {
+		name: name.toUpperCase(),
+		type: type.toUpperCase(),
+		suffix: suffixOrExt && suffixOrExt !== extension ? suffixOrExt : void 0,
+		extension
+	};
+	return null;
+}
+/**
+* Deserialize abapGit files to ADK objects
+*
+* True generator - yields objects one at a time as they're discovered.
+* Resolves packageRef using abapGit folder logic when rootPackage is provided.
+*
+* @param fileTree - Virtual file system to read from
+* @param client - ADT client for creating ADK objects
+* @param options - Export options (root package, language version, etc.)
+*/
+async function* deserialize(fileTree, client, options) {
+	const adk = createAdk(client);
+	let folderLogic = "prefix";
+	let startDir = "";
+	const hasAbapGitXml = await fileTree.exists(".abapgit.xml");
+	if (hasAbapGitXml) try {
+		const meta = parseAbapGitMetadata(await fileTree.read(".abapgit.xml"));
+		folderLogic = meta.folderLogic;
+		startDir = stripSlashes(meta.startingFolder);
+	} catch {}
+	const xmlFiles = await fileTree.glob("**/*.xml");
+	const objectMap = /* @__PURE__ */ new Map();
+	const supportedTypes = new Set(getSupportedTypes().map((t) => t.toLowerCase()));
+	for (const xmlPath of xmlFiles) {
+		if (xmlPath.endsWith(".abapgit.xml")) continue;
+		if (xmlPath.endsWith("package.devc.xml")) continue;
+		const parsed = parseAbapGitFilename(xmlPath.split("/").pop());
+		if (!parsed) continue;
+		if (!supportedTypes.has(parsed.type.toLowerCase())) continue;
+		if (parsed.suffix) continue;
+		const key = `${parsed.name}:${parsed.type}`;
+		if (!objectMap.has(key)) objectMap.set(key, {
+			name: parsed.name,
+			type: parsed.type,
+			sourceFiles: []
+		});
+		const obj = objectMap.get(key);
+		obj.xmlFile = xmlPath;
+	}
+	const abapFiles = await fileTree.glob("**/*.abap");
+	for (const abapPath of abapFiles) {
+		const parsed = parseAbapGitFilename(abapPath.split("/").pop());
+		if (!parsed) continue;
+		const key = `${parsed.name}:${parsed.type}`;
+		const obj = objectMap.get(key);
+		if (obj) obj.sourceFiles.push({
+			path: abapPath,
+			suffix: parsed.suffix
+		});
+	}
+	for (const [, objFiles] of objectMap) {
+		if (!objFiles.xmlFile) continue;
+		const handler = getHandler(objFiles.type);
+		if (!handler) continue;
+		try {
+			const xmlContent = await fileTree.read(objFiles.xmlFile);
+			const values = handler.schema.parse(xmlContent)?.abapGit?.abap?.values ?? {};
+			const sources = {};
+			for (const { path, suffix } of objFiles.sourceFiles) {
+				const content = await fileTree.read(path);
+				const sourceKey = suffix ? handler.suffixToSourceKey?.[suffix] ?? suffix : "main";
+				sources[sourceKey] = content;
+			}
+			const payload = handler.fromAbapGit ? handler.fromAbapGit(values) : { name: objFiles.name };
+			const objectName = payload.name || objFiles.name;
+			const fullData = {
+				...payload,
+				name: objectName
+			};
+			const adkType = typeof payload.type === "string" ? payload.type : objFiles.type;
+			const adkObject = adk.getWithData(fullData, adkType);
+			if (Object.keys(sources).length > 0) if (handler.setSources) handler.setSources(adkObject, sources);
+			else {
+				if (sources["main"]) adkObject._pendingSource = sources["main"];
+				if (Object.keys(sources).length > 1) adkObject._pendingSources = sources;
+			}
+			if (payload.description) adkObject._pendingDescription = payload.description;
+			if (hasAbapGitXml) {
+				const sourceDir = objFiles.xmlFile.split("/").slice(0, -1).join("/");
+				adkObject._relDir = sourceDir.startsWith(startDir) ? sourceDir.slice(startDir.length).replace(/^\/+/, "") : sourceDir;
+				adkObject._folderLogic = folderLogic;
+			}
+			if (options?.rootPackage) {
+				const data = adkObject._data;
+				if (data && !data.packageRef) if (hasAbapGitXml) data.packageRef = { name: resolvePackageFromDir(adkObject._relDir ?? "", folderLogic, options.rootPackage) };
+				else data.packageRef = { name: options.rootPackage };
+			}
+			if (options?.abapLanguageVersion) {
+				const data = adkObject._data;
+				if (data && !data.abapLanguageVersion) data.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
+			}
+			yield adkObject;
+			if (objFiles.type === "FUGR" && payload._functions) {
+				const fmDescriptors = extractFunctionDescriptors(payload._functions);
+				const fmSources = adkObject._pendingFmSources;
+				for (const fm of fmDescriptors) try {
+					const fmData = {
+						name: fm.funcName,
+						type: "FUGR/FF",
+						_groupName: objectName,
+						description: fm.shortText ?? "",
+						processingType: fm.processingType,
+						basXMLEnabled: fm.basXMLEnabled
+					};
+					const fmObject = adk.getWithData(fmData, "FUGR/FF");
+					const fmSourceKey = fm.funcName.toLowerCase();
+					const fmSource = fmSources?.[fmSourceKey];
+					if (fmSource) fmObject._pendingSource = fmSource;
+					if (options?.abapLanguageVersion) {
+						const fmObjData = fmObject._data;
+						if (fmObjData && !fmObjData.abapLanguageVersion) fmObjData.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
+					}
+					yield fmObject;
+				} catch (fmError) {
+					console.error(`Failed to deserialize FM ${fm.funcName} in FUGR ${objectName}:`, fmError);
+				}
+			}
+		} catch (error) {
+			console.error(`Failed to deserialize ${objFiles.type} ${objFiles.name}:`, error);
+		}
+	}
+}
+
+//#endregion
+//#region src/lib/format-plugin.ts
+const abapgitFormatPlugin = {
+	id: "abapgit",
+	description: "abapGit serialization format",
+	get supportedTypes() {
+		return getSupportedTypes();
+	},
+	getHandler(type) {
+		return getHandler(type);
+	},
+	parseFilename(filename) {
+		return parseAbapGitFilename(filename) ?? void 0;
+	}
+};
+
+//#endregion
+//#region src/lib/serializer.ts
+/**
+* Serialize ADK objects to abapGit format
+*
+* This class uses the handler registry to delegate serialization
+* to type-specific handlers.
+*/
+var AbapGitSerializer = class {
+	/**
+	* Serialize a single object (called by plugin API)
+	*/
+	async serializeObjectPublic(obj, targetPath, packageDir) {
+		const fullPackageDir = join(targetPath, "src", packageDir);
+		mkdirSync(fullPackageDir, { recursive: true });
+		const objectType = getTypeForKind(obj.kind) ?? obj.type;
+		const handler = getHandler(objectType);
+		if (!handler) throw new Error(`No handler available for object type: ${objectType} (kind: ${obj.kind})`);
+		const serializedFiles = await handler.serialize(obj);
+		const writtenFiles = [];
+		for (const file of serializedFiles) {
+			const filePath = join(fullPackageDir, file.path);
+			writeFileSync(filePath, file.content, file.encoding ?? "utf8");
+			writtenFiles.push(filePath);
+		}
+		return writtenFiles;
+	}
+};
+
+//#endregion
+//#region src/lib/abapgit.ts
+const serializer = new AbapGitSerializer();
+let currentFolderLogic = "prefix";
+/**
+* Recursively collect all file paths under a directory.
+*/
+function walkDir(dir, results = []) {
+	if (!existsSync(dir)) return results;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) walkDir(full, results);
+		else results.push(full);
+	}
+	return results;
+}
+/**
+* Lazy per-srcDir file index.
+*
+* Maps srcDir → (prefix → [absolute file paths]), where prefix is
+* `${name}.${type}.` in lower-case.  Built at most once per srcDir per
+* process, so the O(repo-size) directory walk is amortised across all
+* `format.delete()` calls in a single import run instead of repeated for
+* every deleted object.
+*/
+const srcDirIndexCache = /* @__PURE__ */ new Map();
+function getOrBuildSrcIndex(srcDir) {
+	const cached = srcDirIndexCache.get(srcDir);
+	if (cached) return cached;
+	const index = /* @__PURE__ */ new Map();
+	for (const filePath of walkDir(srcDir)) {
+		const fname = basename(filePath).toLowerCase();
+		const first = fname.indexOf(".");
+		if (first === -1) continue;
+		const second = fname.indexOf(".", first + 1);
+		if (second === -1) continue;
+		const key = fname.substring(0, second + 1);
+		const bucket = index.get(key);
+		if (bucket) bucket.push(filePath);
+		else index.set(key, [filePath]);
+	}
+	srcDirIndexCache.set(srcDir, index);
+	return index;
+}
+/**
+* Find all abapGit files for a given object name and type.
+*
+* abapGit naming convention: `{name}.{type}[.suffix].{ext}`
+* e.g. `zcl_foo.clas.xml`, `zcl_foo.clas.locals_def.abap`
+*
+* Matching is done on the filename base: `{name}.{type}.`.  SAP ABAP object
+* names and types **never contain a dot**, so the prefix is unambiguous —
+* `ztabl_del.tabl.` cannot accidentally match `ztabl_del_ext.tabl.xml`
+* because the separator after `ztabl_del` in the prefix is `.` while the
+* other file has `_ext.`.
+*
+* Uses a lazy per-srcDir index so the directory tree is walked at most once
+* per deletion batch rather than once per object.
+*/
+function findObjectFiles(srcDir, name, type) {
+	const prefix = `${name.toLowerCase()}.${type.toLowerCase()}.`;
+	return getOrBuildSrcIndex(srcDir).get(prefix) ?? [];
+}
+function readFolderLogicFromExistingRepo(targetPath) {
+	const abapgitXmlPath = join(targetPath, ".abapgit.xml");
+	if (!existsSync(abapgitXmlPath)) return;
+	try {
+		return parseFolderLogicFromAbapGitXml(readFileSync(abapgitXmlPath, "utf-8"));
+	} catch {
+		return;
+	}
+}
+function resolveFolderLogic(context, targetPath) {
+	const cliFolderLogic = parseFolderLogic(context.formatOptions?.folderLogic);
+	if (cliFolderLogic) return cliFolderLogic;
+	const existingRepoFolderLogic = readFolderLogicFromExistingRepo(targetPath);
+	if (existingRepoFolderLogic) return existingRepoFolderLogic;
+	const configuredFolderLogic = parseFolderLogic(context.configFormatOptions?.folderLogic);
+	if (configuredFolderLogic) return configuredFolderLogic;
+	return "prefix";
+}
+/**
+* abapGit Plugin
+*
+* Provides import/export of ADK objects to abapGit repository format.
+*/
+const abapGitPlugin = createPlugin({
+	name: "abapGit",
+	version: "1.0.0",
+	description: "abapGit format plugin for ADK objects",
+	registry: {
+		isSupported,
+		getSupportedTypes
+	},
+	format: {
+		async import(object, targetPath, context) {
+			try {
+				const objPackage = object.type?.startsWith("DEVC") ? object.name : object.package || object.name || "ROOT";
+				const packagePath = await context.resolvePackagePath(objPackage);
+				const folderLogic = resolveFolderLogic(context, targetPath);
+				currentFolderLogic = folderLogic;
+				const packageDir = calculatePackageDir(packagePath, folderLogic);
+				return {
+					success: true,
+					filesCreated: await serializer.serializeObjectPublic(object, targetPath, packageDir)
+				};
+			} catch (error) {
+				return {
+					success: false,
+					filesCreated: [],
+					errors: [error instanceof Error ? error.message : String(error)]
+				};
+			}
+		},
+		export: (fileTree, client, options) => deserialize(fileTree, client, options),
+		async delete(objectRef, targetPath, _context) {
+			try {
+				const matchedFiles = findObjectFiles(join(targetPath, "src"), objectRef.name, objectRef.type);
+				const filesRemoved = [];
+				const errors = [];
+				for (const filePath of matchedFiles) try {
+					unlinkSync(filePath);
+					filesRemoved.push(relative(targetPath, filePath));
+				} catch (error) {
+					if (error.code === "ENOENT") {
+						filesRemoved.push(relative(targetPath, filePath));
+						continue;
+					}
+					errors.push(error instanceof Error ? `Failed to delete ${relative(targetPath, filePath)}: ${error.message}` : `Failed to delete ${relative(targetPath, filePath)}: ${String(error)}`);
+				}
+				return {
+					success: errors.length === 0,
+					filesRemoved,
+					...errors.length > 0 ? { errors } : {}
+				};
+			} catch (error) {
+				return {
+					success: false,
+					filesRemoved: [],
+					errors: [error instanceof Error ? error.message : String(error)]
+				};
+			}
+		}
+	},
+	hooks: { async afterImport(targetPath) {
+		mkdirSync(targetPath, { recursive: true });
+		writeFileSync(join(targetPath, ".abapgit.xml"), generateAbapGitXml(currentFolderLogic), "utf-8");
+	} }
+});
+
+//#endregion
+//#region src/lib/filename/adt-uri-to-path.ts
+/**
+* Convert an ADT URI to an on-disk abapGit filename.
+*
+* abapGit stores objects as `<name>.<type>.<ext>` inside `src/`.
+* Classes have additional includes serialised as
+* `<name>.clas.<suffix>.abap`. Function modules become
+* `<group>.fugr.<fm_name>.abap`. Namespaces are rendered as
+* `(namespace)name`.
+*
+* Returns `null` for URIs we don't recognise; callers may warn or fall
+* back to a synthetic path.
+*/
+/**
+* Apply abapGit namespace transform: `/MYNS/zcl_foo` → `(myns)zcl_foo`.
+* Case is lower-cased afterwards; name without namespace returned as-is
+* (lower-cased).
+*/
+function applyNamespace(raw) {
+	const nsMatch = /^\/([^/]+)\/(.*)$/.exec(raw);
+	if (nsMatch) {
+		const [, ns, rest] = nsMatch;
+		return `(${ns.toLowerCase()})${rest.toLowerCase()}`;
+	}
+	return raw.toLowerCase();
+}
+function stripFragment(uri) {
+	const hashIndex = uri.indexOf("#");
+	return hashIndex >= 0 ? uri.slice(0, hashIndex) : uri;
+}
+const CLASS_INCLUDE_TO_SUFFIX = {
+	testclasses: ABAPGIT_SUFFIX.testclasses,
+	definitions: ABAPGIT_SUFFIX.definitions,
+	implementations: ABAPGIT_SUFFIX.implementations,
+	macros: ABAPGIT_SUFFIX.macros,
+	localtypes: ABAPGIT_SUFFIX.localtypes
+};
+const RULES = [
+	{
+		test: /^\/sap\/bc\/adt\/oo\/classes\/([^/]+)\/includes\/([^/]+)$/,
+		build: (m) => {
+			const name = applyNamespace(decodeURIComponent(m[1]));
+			const include = m[2].toLowerCase();
+			const suffix = CLASS_INCLUDE_TO_SUFFIX[include];
+			return suffix ? `src/${name}.clas.${suffix}.abap` : `src/${name}.clas.${include}.abap`;
+		}
+	},
+	{
+		test: /^\/sap\/bc\/adt\/oo\/classes\/([^/]+)\/source\/main$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.clas.abap`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/oo\/classes\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.clas.abap`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/oo\/interfaces\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.intf.abap`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/programs\/programs\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.prog.abap`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/functions\/groups\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.fugr.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/functions\/groups\/([^/]+)\/fmodules\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => {
+			return `src/${applyNamespace(decodeURIComponent(m[1]))}.fugr.${applyNamespace(decodeURIComponent(m[2]))}.abap`;
+		}
+	},
+	{
+		test: /^\/sap\/bc\/adt\/functions\/groups\/([^/]+)\/includes\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => {
+			return `src/${applyNamespace(decodeURIComponent(m[1]))}.fugr.${applyNamespace(decodeURIComponent(m[2]))}.abap`;
+		}
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/ddl\/sources\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.ddls.asddls`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/acm\/dcl\/sources\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.dcls.asdcls`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/bo\/behaviordefinitions\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.bdef.abdl`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/srvd\/sources\/([^/]+?)(?:\/source\/main)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.srvd.asrvd`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/businessservices\/bindings\/([^/]+?)(?:\/publishedstates)?$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.srvb.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/domains\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.doma.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/dataelements\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.dtel.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/structures\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.tabl.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/ddic\/tables\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.tabl.xml`
+	},
+	{
+		test: /^\/sap\/bc\/adt\/packages\/([^/]+)$/,
+		build: (m) => `src/${applyNamespace(decodeURIComponent(m[1]))}.devc.xml`
+	}
+];
+/**
+* Convert an ADT URI to the abapGit on-disk filename (lower-cased,
+* namespace-aware). Returns `null` when the URI shape is not recognised.
+*/
+function adtUriToAbapGitPath(uri) {
+	if (!uri) return null;
+	const clean = stripFragment(uri).trim();
+	for (const rule of RULES) {
+		const m = rule.test.exec(clean);
+		if (m) return rule.build(m);
+	}
+	return null;
+}
+
+//#endregion
+//#region src/index.ts
+registerFormatPlugin(abapgitFormatPlugin);
+
+//#endregion
+export { abapGitPlugin as AbapGitPlugin, abapGitPlugin, abapGitPlugin as default, abapgitFormatPlugin, adtUriToAbapGitPath, createFindingResolver, formatAbapGitXml, formatXmlAttributes, getHandler, getSupportedTypes, isSupported, moveNamespaceToAbap, parseAbapGitFilename, parseAbapGitMetadata, resolvePackageFromDir, reverseResolveRootPackage };
+//# sourceMappingURL=index.mjs.map