@abapify/adt-plugin-abapgit 0.4.1 → 0.4.3

package/dist/index.mjs

@@ -1,11 +1,11 @@
-import { createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
+import { FormatMaterializationError, createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
+import { basename, dirname, isAbsolute, join, posix, relative, sep } from "node:path";
 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";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { adtUriToAbapGitPath, createAbapGitResolver as createFindingResolver } from "@abapify/adt-atc";
 
 //#region src/lib/handlers/xml-format.ts
 /**
@@ -190,7 +190,8 @@ function createHandler(adkClassOrType, definition) {
 				serializer: definition.serializer,
 				serializer_version: definition.serializer_version
 			};
-			return formatAbapGitXml(definition.schema.build(fullPayload, { pretty: true }));
+			const xml = definition.schema.build(fullPayload, { pretty: true });
+			return formatAbapGitXml(xml);
 		},
 		createFile(path, content, encoding) {
 			return {
@@ -212,37 +213,67 @@ function createHandler(adkClassOrType, definition) {
 			};
 		}
 	};
-	const defaultSerialize = async (object) => {
+	function resolveXmlFileName(object) {
+		if (definition.xmlFileName) return typeof definition.xmlFileName === "function" ? definition.xmlFileName(object, ctx) : definition.xmlFileName;
+		return `${ctx.getObjectName(object)}.${fileExtension}.xml`;
+	}
+	function createExplicitSourceFile(sourceKey, content, suffixBySourceKey, objectName) {
+		if (content === void 0) return void 0;
+		if (!suffixBySourceKey.has(sourceKey)) throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", `The ${type} format handler cannot map source component "${sourceKey}".`);
+		return ctx.createAbapFile(objectName, content, suffixBySourceKey.get(sourceKey));
+	}
+	function buildExplicitSourceFiles(object, sources) {
+		const sourceKeys = Object.keys(sources);
+		if (sourceKeys.length === 0) return [];
+		if (!definition.getSource && !definition.getSources) throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", `The ${type} format handler does not serialize source components.`);
+		const suffixBySourceKey = new Map([["main", void 0], ...Object.entries(definition.suffixToSourceKey ?? {}).map(([suffix, sourceKey]) => [sourceKey, suffix])]);
 		const objectName = ctx.getObjectName(object);
 		const files = [];
+		for (const sourceKey of sourceKeys.sort((left, right) => left.localeCompare(right, "en-US"))) {
+			const file = createExplicitSourceFile(sourceKey, sources[sourceKey], suffixBySourceKey, objectName);
+			if (file) files.push(file);
+		}
+		return files;
+	}
+	async function buildMutableSourceFiles(object) {
+		const objectName = ctx.getObjectName(object);
 		if (definition.getSources) {
 			const rawSources = definition.getSources(object);
-			const sources = await Promise.all(rawSources.map(async ({ suffix, content }) => ({
+			return (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) {
+			})))).filter(({ content }) => content).map(({ suffix, content }) => ctx.createAbapFile(objectName, content, suffix));
+		}
+		if (definition.getSource) {
 			const source = await definition.getSource(object);
-			files.push(ctx.createAbapFile(objectName, source));
+			return source ? [ctx.createAbapFile(objectName, source)] : [];
 		}
+		return [];
+	}
+	const defaultSerialize = async (object, options) => {
+		const sourceFiles = options?.sources !== void 0 ? buildExplicitSourceFiles(object, options.sources) : await buildMutableSourceFiles(object);
+		const xmlFileName = resolveXmlFileName(object);
 		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;
+		return [...sourceFiles, ctx.createFile(xmlFileName, xmlContent)];
 	};
 	const defaultFromAbapGit = definition.fromAbapGit ? (values) => {
 		return definition.fromAbapGit(values);
 	} : void 0;
+	const explicitSupports = definition.supportsExplicitSources;
+	const serializeAcceptsOptions = explicitSupports ?? (definition.serialize !== void 0 && definition.serialize.length >= 3);
+	const supportsExplicitSources = explicitSupports ?? (definition.getSource !== void 0 || definition.getSources !== void 0 || serializeAcceptsOptions);
 	const handler = {
 		type,
 		fileExtension,
 		schema: definition.schema,
 		suffixToSourceKey: definition.suffixToSourceKey,
-		serialize: definition.serialize ? (object) => definition.serialize(object, ctx) : defaultSerialize,
+		supportsExplicitSources,
+		serialize: definition.serialize ? async (object, options) => {
+			if (serializeAcceptsOptions) return await definition.serialize(object, ctx, options);
+			return await definition.serialize(object, ctx);
+		} : defaultSerialize,
 		fromAbapGit: defaultFromAbapGit,
+		fromAffJson: definition.fromAffJson,
 		setSources: definition.setSources
 	};
 	handlerRegistry.set(type, handler);
@@ -2358,89 +2389,1718 @@ var srvb_default = {
 };
 
 //#endregion
-//#region src/schemas/generated/index.ts
+//#region src/schemas/generated/schemas/dcls.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
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/dcls.xsd
 */
-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);
+var dcls_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: "DclsAbapType"
+			}] },
+			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: "DclsValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "DclsAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "DclsValuesType"
+			}] },
+			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/lib/handlers/lang.ts
+//#region src/schemas/generated/schemas/ddls.ts
 /**
-* SAP 1-character language code ↔ ISO 639-1 mapping
+* Auto-generated schema from XSD
 *
-* abapGit stores SAP internal 1-char codes (e.g. "E" for English).
-* SAP ADT REST API expects ISO 639-1 codes (e.g. "EN").
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/ddls.xsd
 */
-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"
+var ddls_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: "DdlsAbapType"
+			}] },
+			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: "DdlsValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "DdlsAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "DdlsValuesType"
+			}] },
+			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"
+			}]
+		}
+	]
 };
-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;
-}
+
+//#endregion
+//#region src/schemas/generated/schemas/ddlx.ts
 /**
-* Convert ISO 639-1 language code to SAP 1-char code.
-* Returns "E" (English) if no mapping exists.
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/ddlx.xsd
 */
-function isoToSapLang(isoLang) {
-	if (!isoLang) return "E";
+var ddlx_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: "DdlxAbapType"
+			}] },
+			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: "DdlxValuesType",
+			all: { element: [{
+				name: "SKEY",
+				type: "SkeyType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "DdlxAbapType",
+			sequence: { element: [{
+				name: "values",
+				type: "DdlxValuesType"
+			}] },
+			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/msag.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/msag.xsd
+*/
+var msag_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: "T100A",
+				type: "asx:T100aType",
+				minOccurs: "0"
+			}, {
+				name: "T100",
+				type: "asx:T100TabType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "T100aType",
+			all: { element: [
+				{
+					name: "ARBGB",
+					type: "xs:string"
+				},
+				{
+					name: "MASTERLANG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "STEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "T100Type",
+			sequence: { element: [
+				{
+					name: "SPRSL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ARBGB",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MSGNR",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "T100TabType",
+			sequence: { element: [{
+				name: "item",
+				type: "T100Type",
+				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/view.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/view.xsd
+*/
+var view_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: "DD25V",
+					type: "asx:Dd25vType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD26V_TABLE",
+					type: "asx:Dd26vTabType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD27P_TABLE",
+					type: "asx:Dd27pTabType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD28V_TABLE",
+					type: "asx:Dd28vTabType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd25vType",
+			all: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VIEWCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROOTTAB",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROOTFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ACTFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MULTITAB",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd26vType",
+			sequence: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABPOS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FVIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FFIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "READONLY",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd26vTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd26vType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "Dd27pType",
+			sequence: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VIEWFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KEYFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "READONLY",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROLLNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CHECKTABLE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LOGFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFTABLE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OUTPUTLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONVEXIT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd27pTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd27pType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "Dd28vType",
+			sequence: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ANDOR",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LEFTBRACKET",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OPERATOR",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONST_VALUE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "RIGHTBRACKET",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd28vTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd28vType",
+				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/enqu.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/enqu.xsd
+*/
+var enqu_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: "DD25V",
+					type: "asx:Dd25vType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD26V_TABLE",
+					type: "asx:Dd26vTabType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD27P_TABLE",
+					type: "asx:Dd27pTabType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd25vType",
+			all: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VIEWCLASS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROOTTAB",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROOTFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ACTFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "MULTITAB",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd26vType",
+			sequence: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABPOS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FVIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FFIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "READONLY",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd26vTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd26vType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "Dd27pType",
+			sequence: { element: [
+				{
+					name: "VIEWNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "VIEWFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "KEYFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "READONLY",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROLLNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CHECKTABLE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "LOGFLAG",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFTABLE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "REFFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "OUTPUTLEN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CONVEXIT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd27pTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd27pType",
+				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/shlp.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/shlp.xsd
+*/
+var shlp_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: "DD30V",
+					type: "asx:Dd30vType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD31V",
+					type: "asx:Dd31vType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD32P_TABLE",
+					type: "asx:Dd32pTabType",
+					minOccurs: "0"
+				},
+				{
+					name: "DD33V_TABLE",
+					type: "asx:Dd33vTabType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd30vType",
+			all: { element: [
+				{
+					name: "SHLPNAME",
+					type: "xs:string"
+				},
+				{
+					name: "DDLANGUAGE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPINPUT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DEFLOOKUP",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DIALOGTYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SELEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ACTMETHOD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "HOTKEY",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd31vType",
+			all: { element: [
+				{
+					name: "SHLPNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FLDLOCATION",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROLLNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd32pType",
+			sequence: { element: [
+				{
+					name: "SHLPNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPINPUT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPOUTPUT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPSELPOS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPLISPOS",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DEFAULTVAL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "ROLLNAME",
+					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: "DDTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd32pTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd32pType",
+				minOccurs: "0",
+				maxOccurs: "unbounded"
+			}] }
+		},
+		{
+			name: "Dd33vType",
+			sequence: { element: [
+				{
+					name: "SHLPNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPFIELD",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TABNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "FIELDNAME",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPINPUT",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "SHLPOUTPUT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "Dd33vTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "Dd33vType",
+				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/tran.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/tran.xsd
+*/
+var tran_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: "TSTC",
+					type: "asx:TstcType",
+					minOccurs: "0"
+				},
+				{
+					name: "TSTCC",
+					type: "asx:TstccType",
+					minOccurs: "0"
+				},
+				{
+					name: "TSTCT",
+					type: "asx:TstctTabType",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TstcType",
+			all: { element: [
+				{
+					name: "TCODE",
+					type: "xs:string"
+				},
+				{
+					name: "PGMNA",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "DYPNO",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TYPE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "CINFO",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TstccType",
+			all: { element: [
+				{
+					name: "TCODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "S_WEBGUI",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "S_PLATIN",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "S_WIN32",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "S_MAC",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TstctType",
+			sequence: { element: [
+				{
+					name: "SPRSL",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TCODE",
+					type: "xs:string",
+					minOccurs: "0"
+				},
+				{
+					name: "TTEXT",
+					type: "xs:string",
+					minOccurs: "0"
+				}
+			] }
+		},
+		{
+			name: "TstctTabType",
+			sequence: { element: [{
+				name: "item",
+				type: "TstctType",
+				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/type.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/type.xsd
+*/
+var type_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: "TYPE",
+				type: "asx:TypeGroupType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "TypeGroupType",
+			all: { element: [{
+				name: "TYPEGROUP",
+				type: "xs:string"
+			}, {
+				name: "DESCRIPT",
+				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/xslt.ts
+/**
+* Auto-generated schema from XSD
+*
+* DO NOT EDIT - Generated by ts-xsd codegen
+* Source: abapgit/xslt.xsd
+*/
+var xslt_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: "XSLT",
+				type: "asx:XsltType",
+				minOccurs: "0"
+			}] }
+		},
+		{
+			name: "XsltType",
+			all: { element: [{
+				name: "PROGNAME",
+				type: "xs:string"
+			}, {
+				name: "DESCRIPT",
+				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/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);
+const dcls = abapGitSchema(dcls_default);
+const ddls = abapGitSchema(ddls_default);
+const ddlx = abapGitSchema(ddlx_default);
+const msag = abapGitSchema(msag_default);
+const view = abapGitSchema(view_default);
+const enqu = abapGitSchema(enqu_default);
+const shlp = abapGitSchema(shlp_default);
+const tran = abapGitSchema(tran_default);
+const type = abapGitSchema(type_default);
+const xslt = abapGitSchema(xslt_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";
@@ -2680,6 +4340,19 @@ const programHandler = createHandler(AdkProgram, {
 	}
 });
 
+//#endregion
+//#region src/lib/handlers/source-inclusion.ts
+/**
+* Shared source-inclusion rule for abapGit object handlers.
+*
+* A source is included when it is defined and either supplied by the caller
+* or non-empty on the object.
+*/
+function shouldIncludeSource(source, suppliedSource) {
+	if (source === void 0) return false;
+	return suppliedSource !== void 0 || source !== "";
+}
+
 //#endregion
 //#region src/lib/handlers/objects/fugr.ts
 /**
@@ -2696,6 +4369,75 @@ const programHandler = createHandler(AdkProgram, {
 * Note: FM metadata is stored INSIDE the main XML under <FUNCTIONS>,
 * NOT in separate per-FM XML files (that's how abapGit works).
 */
+function buildMainXmlFile(obj, objectName, nameUpper, functions, ctx) {
+	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"
+	} };
+	const xmlContent = formatAbapGitXml(fugr.build(fullPayload, { pretty: true }));
+	return ctx.createFile(`${objectName}.fugr.xml`, xmlContent);
+}
+function deriveFmList(suppliedSources, objectName) {
+	if (!suppliedSources) return {
+		fmItems: [],
+		functions: []
+	};
+	const lowerTopKey = `l${objectName}top`;
+	const lowerSap = `sapl${objectName}`;
+	const fmItems = Object.keys(suppliedSources).filter((key) => {
+		const lower = key.toLowerCase();
+		return lower !== "main" && lower !== lowerTopKey && lower !== lowerSap;
+	}).map((key) => ({
+		key,
+		name: key.toLowerCase()
+	}));
+	return {
+		fmItems,
+		functions: fmItems.map((fm) => ({ FUNCNAME: fm.key.toUpperCase() }))
+	};
+}
+async function buildTopSourceFile(obj, objectName, suppliedSources, ctx) {
+	const hasExplicitSources = suppliedSources !== void 0;
+	const topKey = `l${objectName}top`;
+	const suppliedTopSource = suppliedSources ? suppliedSources.main ?? suppliedSources[topKey] : void 0;
+	try {
+		const topSource = suppliedTopSource !== void 0 || !hasExplicitSources ? suppliedTopSource ?? await obj.getSource() : void 0;
+		if (shouldIncludeSource(topSource, suppliedTopSource)) return ctx.createFile(`${objectName}.fugr.l${objectName}top.abap`, topSource);
+	} catch {}
+}
+function buildProgramFiles(objectName, nameUpper, fixpt, ctx) {
+	return [
+		ctx.createFile(`${objectName}.fugr.l${objectName}top.xml`, buildProgdirXml(`L${nameUpper}TOP`, "I", fixpt)),
+		ctx.createFile(`${objectName}.fugr.sapl${objectName}.abap`, buildMainProgramSource(nameUpper)),
+		ctx.createFile(`${objectName}.fugr.sapl${objectName}.xml`, buildProgdirXml(`SAPL${nameUpper}`, "F", fixpt))
+	];
+}
+async function buildFunctionModuleFiles(obj, fmItems, suppliedSources, ctx) {
+	const objectName = ctx.getObjectName(obj);
+	const files = [];
+	const hasExplicitSources = suppliedSources !== void 0;
+	for (const fm of fmItems) {
+		const sourceKey = fm.key ?? fm.name;
+		const funcName = fm.name.toLowerCase();
+		const suppliedFmSource = suppliedSources?.[sourceKey];
+		if (hasExplicitSources && suppliedFmSource === void 0) continue;
+		try {
+			const source = suppliedFmSource !== void 0 ? suppliedFmSource : await obj.client.adt.functions.groups.fmodules.source.main.get(obj.name, fm.name);
+			if (shouldIncludeSource(source, suppliedFmSource)) files.push(ctx.createFile(`${objectName}.fugr.${funcName}.abap`, source));
+		} catch {}
+	}
+	return files;
+}
 /**
 * Map ADT processingType to abapGit REMOTE_CALL flag
 */
@@ -2726,44 +4468,26 @@ const functionGroupHandler = createHandler(AdkFunctionGroup, {
 			INCLUDES: { SOBJ_NAME: [`L${name}TOP`, `SAPL${name}`] }
 		};
 	},
-	serialize: async (obj, ctx) => {
+	serialize: async (obj, ctx, options) => {
 		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 {}
+		const suppliedSources = options?.sources;
+		const hasExplicitSources = suppliedSources !== void 0;
+		let fmItems;
+		let functions;
+		if (hasExplicitSources) ({fmItems, functions} = deriveFmList(suppliedSources, objectName));
+		else {
+			fmItems = await discoverFunctionModules(obj);
+			functions = await serializeFunctions(obj, fmItems);
 		}
-		return files;
+		const fixpt = ctx.getData(obj).fixPointArithmetic ? "X" : "";
+		const topFile = await buildTopSourceFile(obj, objectName, suppliedSources, ctx);
+		return [
+			buildMainXmlFile(obj, objectName, nameUpper, functions, ctx),
+			...topFile ? [topFile] : [],
+			...buildProgramFiles(objectName, nameUpper, fixpt, ctx),
+			...await buildFunctionModuleFiles(obj, fmItems, suppliedSources, ctx)
+		];
 	},
 	fromAbapGit: ({ AREAT, FUNCTIONS }) => ({
 		name: "",
@@ -2779,8 +4503,9 @@ const functionGroupHandler = createHandler(AdkFunctionGroup, {
 		const mainSource = sources.main ?? sources[topKey];
 		if (mainSource) obj._pendingSource = mainSource;
 		const fmSources = {};
+		const mainProgramKey = `sapl${name}`;
 		for (const [suffix, content] of Object.entries(sources)) {
-			if (suffix === "main" || suffix === topKey || suffix.startsWith(`l${name}`) || suffix.startsWith(`sapl${name}`)) continue;
+			if (suffix === "main" || suffix === topKey || suffix === mainProgramKey) continue;
 			fmSources[suffix] = content;
 		}
 		if (Object.keys(fmSources).length > 0) obj._pendingFmSources = fmSources;
@@ -2799,7 +4524,7 @@ async function discoverFunctionModules(obj) {
 		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] });
+		while ((match = regex2.exec(responseStr)) !== null) if (match?.[1] && !fmNames.some((f) => f.name === match[1])) fmNames.push({ name: match[1] });
 		return fmNames;
 	} catch {
 		return [];
@@ -3441,451 +5166,1377 @@ async function buildDD03P(members, tableName = "", resolver) {
 		const field = member;
 		entries.push(await buildFieldDD03P(field, tableName, resolver));
 	}
-	return entries;
-}
+	return entries;
+}
+
+//#endregion
+//#region src/lib/handlers/objects/tabl-serialize.ts
+/**
+* Table/Structure serialization helpers for abapGit format.
+*
+* This file contains the source-to-XML conversion used by the TABL handler.
+* It is intentionally separate from the handler definition file, which keeps
+* the handler surface focused on schema mapping (`toAbapGit`/`fromAbapGit`).
+*/
+const XML_NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+function decodeNumericCode(decimal, hex) {
+	const base = decimal !== void 0 ? 10 : 16;
+	const value = decimal !== void 0 ? decimal : hex ?? "";
+	return String.fromCharCode(parseInt(value, base));
+}
+function decodeXmlEntities(text) {
+	return text.replace(/&(?:#(\d+)|#x([0-9a-fA-F]+)|([a-zA-Z][a-zA-Z0-9]*));/g, (match, decimal, hex, name) => decimal !== void 0 || hex !== void 0 ? decodeNumericCode(decimal, hex) : XML_NAMED_ENTITIES[name] ?? match);
+}
+/**
+* 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;
+}
+/**
+* Parse ADT table settings XML into DD09L data for abapGit serialization.
+*/
+function parseSettingsToDD09L(settingsXml, def) {
+	let settings;
+	try {
+		const parsed = tablesettings.parse(settingsXml);
+		if (!("tableSettings" in parsed)) return void 0;
+		settings = parsed.tableSettings;
+	} catch {
+		return;
+	}
+	return stripEmpty({
+		TABNAME: def.name.toUpperCase(),
+		AS4LOCAL: "A",
+		TABKAT: settings.sizeCategory,
+		TABART: settings.dataClassCategory,
+		BUFALLOW: settings.buffering?.allowed,
+		PUFFERUNG: settings.buffering?.type,
+		SCHFELDANZ: settings.buffering?.areaKeyFields && settings.buffering.areaKeyFields !== "0" ? settings.buffering.areaKeyFields : void 0,
+		PROTOKOLL: settings.loggingEnabled ? "X" : void 0
+	});
+}
+/**
+* Create a TypeResolver that resolves named types via ADT endpoints.
+*/
+function resolveReferencedType(xml, comptype) {
+	const result = { comptype };
+	if (comptype === "E" && /<dtel:searchHelp>[^<]+<\/dtel:searchHelp>/.test(xml)) result.shlporigin = "D";
+	const descMatch = xml.match(/adtcore:description="([^"]+)"/);
+	if (descMatch) result.description = decodeXmlEntities(descMatch[1]);
+	return result;
+}
+function createAdtTypeResolver(obj) {
+	const cache = /* @__PURE__ */ new Map();
+	return { async resolve(name) {
+		const key = name.toLowerCase();
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const dtelXml = await obj.fetchText(`/sap/bc/adt/ddic/dataelements/${encodeURIComponent(key)}`);
+		if (dtelXml) {
+			const result = resolveReferencedType(dtelXml, "E");
+			cache.set(key, result);
+			return result;
+		}
+		const structXml = await obj.fetchText(`/sap/bc/adt/ddic/structures/${encodeURIComponent(key)}`);
+		const result = structXml ? resolveReferencedType(structXml, "S") : { comptype: "E" };
+		cache.set(key, result);
+		return result;
+	} };
+}
+async function resolveCdsSource(obj, sources) {
+	if (sources !== void 0) {
+		if (sources.main === void 0) return { fallback: true };
+		return { source: sources.main };
+	}
+	try {
+		return { source: await obj.getSource() };
+	} catch {
+		return { fallback: true };
+	}
+}
+function createFallbackFile(obj, ctx) {
+	const objectName = ctx.getObjectName(obj);
+	return [ctx.createFile(`${objectName}.tabl.xml`, ctx.toAbapGitXml(obj))];
+}
+async function buildTablValues(obj, def) {
+	const lang = isoToSapLang(obj.language || void 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);
+			if (dd09l) values.DD09L = stripEmpty(dd09l);
+		}
+	} catch {}
+	if (dd03pEntries.length > 0) values.DD03P_TABLE = { DD03P: dd03pEntries.map((entry) => stripEmpty(entry)) };
+	return values;
+}
+function buildTablXml(obj, ctx, values) {
+	const fullPayload = {
+		abap: {
+			version: "1.0",
+			values
+		},
+		version: "v1.0.0",
+		serializer: "LCL_OBJECT_TABL",
+		serializer_version: "v1.0.0"
+	};
+	return formatAbapGitXml(tabl.build(fullPayload, { pretty: true }));
+}
+async function serializeTabl(obj, ctx, options) {
+	const objectName = ctx.getObjectName(obj);
+	const resolved = await resolveCdsSource(obj, options?.sources);
+	if ("fallback" in resolved) return createFallbackFile(obj, ctx);
+	const { ast, errors } = parse(resolved.source);
+	if (errors.length > 0 || ast.definitions.length === 0) return createFallbackFile(obj, ctx);
+	const def = ast.definitions[0];
+	const xml = buildTablXml(obj, ctx, await buildTablValues(obj, def));
+	return [ctx.createFile(`${objectName}.tabl.xml`, xml)];
+}
+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)
+	};
+}
+
+//#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)
+*/
+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, options) => serializeTabl(obj, ctx, options),
+	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, options) => serializeTabl(obj, ctx, options),
+	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/tabl.ts
+//#region src/lib/handlers/source-resolver.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).
+* Resolve the `main` source component for an AFF source handler.
 *
-* 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)
+* If `sources` is supplied, only the `main` key is accepted — any other
+* key throws `FORMAT_SOURCE_COMPONENT_UNSUPPORTED`. When `sources` is
+* absent, falls back to `object.getSource()`.
 */
+async function resolveMainSource(object, sources, typeLabel) {
+	if (sources !== void 0) {
+		const keys = Object.keys(sources);
+		if (keys.some((key) => key !== "main")) throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", `${typeLabel} only supports the 'main' source component; received ${keys.join(", ")}.`);
+		return sources.main;
+	}
+	return typeof object.getSource === "function" ? await object.getSource() : "";
+}
 /**
-* Strip undefined/empty-string values from an object
-* to avoid emitting empty XML elements
+* Build an AFF JSON metadata file. `extra` fields are merged at the
+* top level alongside `formatVersion` and `header`.
 */
-function stripEmpty(obj) {
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== "") result[key] = value;
-	return result;
+function buildAffJson(description, originalLanguage, abapLanguageVersion, extra = {}) {
+	return `${JSON.stringify({
+		formatVersion: "1",
+		header: {
+			description,
+			originalLanguage: originalLanguage.toLowerCase(),
+			...abapLanguageVersion ? { abapLanguageVersion } : {}
+		},
+		...extra
+	}, null, 2)}\n`;
 }
 /**
-* Create a TypeResolver that resolves named types via ADT endpoints.
-* Tries data element first, then structure. Caches results.
+* Create the source file for an AFF handler if the source should be
+* included. Returns an empty array if the source is absent or empty.
 */
-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;
-	} };
+function createAffSourceFile(ctx, params) {
+	if (params.source === void 0) return [];
+	if (params.suppliedSource === void 0 && params.source === "") return [];
+	const name = ctx.getObjectName(params.object);
+	return [ctx.createFile(`${name}.${ctx.fileExtension}.${params.sourceExt}`, params.source)];
 }
 /**
-* Parse ADT table settings XML into DD09L data for abapGit serialization.
+* Full serialize implementation for AFF source handlers.
 *
-* Uses the typed `tablesettings` schema from @abapify/adt-schemas to parse
-* the ADT endpoint response (/sap/bc/adt/ddic/db/settings/{name}).
+* Handles the complete source+metadata file layout in one call:
+*   `<name>.<ext>.<sourceExt>` — source text (when included)
+*   `<name>.<jsonExt>` — metadata JSON
 *
-* 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
+* `extra` is merged into the JSON body for handler-specific fields
+* (e.g. SRVD's `generalInformation`, DDLS's `sourceOrigin`).
 */
-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;
+async function serializeAffSource(object, ctx, options, config) {
+	const source = await resolveMainSource(object, options, config.typeLabel);
+	const name = ctx.getObjectName(object);
+	return [...createAffSourceFile(ctx, {
+		object,
+		source,
+		suppliedSource: options?.main,
+		sourceExt: config.sourceExt
+	}), ctx.createFile(`${name}.${config.jsonExt}`, buildAffJson(object.description || String(object.name ?? ""), object.originalLanguage ?? "en", object.abapLanguageVersion, config.extra))];
 }
 /**
-* Shared serialize logic for tables and structures.
-* Both use CDS source → DD02V/DD03P mapping.
+* Shared `getSource` handler function for source-driven AFF objects
+* (BDEF, SRVD). Delegates to `obj.getSource()` when available.
 */
-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)];
+function affGetSource(obj) {
+	return typeof obj?.getSource === "function" ? Promise.resolve(obj.getSource()) : Promise.resolve("");
 }
-/** Shared fromAbapGit logic for both tables and structures */
-function fromAbapGitTabl({ DD02V } = {}) {
+/**
+* Shared `fromAbapGit` handler function for source-driven AFF objects.
+* Extracts the uppercased name from the SKEY envelope.
+*/
+function affFromAbapGit(SKEY) {
+	return { name: String(SKEY?.NAME ?? "").toUpperCase() };
+}
+/**
+* Shared `setSources` handler function for source-driven AFF objects.
+* Stores the `main` source on a `_pendingSource` property.
+*/
+function affSetSources(obj, sources) {
+	if (sources.main !== void 0) obj._pendingSource = sources.main;
+}
+/**
+* Shared `fromAffJson` handler function for source-driven AFF objects.
+* Extracts the object name from the JSON header or falls back to the
+* filename-derived name passed in. The AFF JSON format stores the
+* description in `header.description` and the original language in
+* `header.originalLanguage`. Both are preserved for round-trip fidelity.
+*/
+function affFromAffJson(json, fallbackName) {
+	const header = json.header;
 	return {
-		name: (DD02V?.TABNAME ?? "").toUpperCase(),
-		type: DD02V?.TABCLASS === "INTTAB" ? "TABL/DS" : "TABL/DT",
-		description: DD02V?.DDTEXT,
-		language: sapLangToIso(DD02V?.DDLANGUAGE),
-		masterLanguage: sapLangToIso(DD02V?.DDLANGUAGE)
+		name: fallbackName,
+		description: header?.description,
+		originalLanguage: header?.originalLanguage,
+		abapLanguageVersion: header?.abapLanguageVersion
 	};
 }
-const tableHandler = createHandler(AdkTable, {
-	schema: tabl,
+/**
+* Dual-format serialize for objects that support both AFF JSON and legacy XML.
+*
+* When `options.format === 'legacy'`, produces a legacy abapGit XML metadata
+* file (via `ctx.toAbapGitXml`) plus the source file. Otherwise (default or
+* `format === 'aff'`), delegates to `serializeAffSource` to produce the AFF
+* JSON sidecar plus source.
+*/
+async function serializeDualFormat(object, ctx, options, config) {
+	if (options?.format === "legacy") {
+		const source = await resolveMainSource(object, options?.sources, config.typeLabel);
+		const name = ctx.getObjectName(object);
+		const files = [];
+		if (source !== void 0) files.push(ctx.createFile(`${name}.${ctx.fileExtension}.${config.sourceExt}`, source));
+		files.push(ctx.createFile(`${name}.${ctx.fileExtension}.xml`, ctx.toAbapGitXml(object)));
+		return files;
+	}
+	return serializeAffSource(object, ctx, options?.sources, config);
+}
+
+//#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 an `.abdl` file.
+* Supports BOTH formats:
+*   - AFF (default): `.bdef.abdl` source + `.bdef.json` metadata sidecar
+*   - Legacy XML:    `.bdef.abdl` source + `.bdef.xml` metadata
+*
+* File layout (AFF):
+*   src/zbp_foo.bdef.abdl — behavior source text
+*   src/zbp_foo.bdef.json — ABAP File Formats metadata
+*
+* File layout (legacy):
+*   src/zbp_foo.bdef.abdl — behavior source text
+*   src/zbp_foo.bdef.xml  — legacy abapGit XML metadata
+*/
+const behaviorDefinitionHandler = createHandler("BDEF", {
+	schema: bdef,
 	version: "v1.0.0",
-	serializer: "LCL_OBJECT_TABL",
+	serializer: "LCL_OBJECT_BDEF",
 	serializer_version: "v1.0.0",
-	toAbapGit: (obj) => ({ DD02V: {
-		TABNAME: obj.name ?? "",
-		DDLANGUAGE: isoToSapLang(obj.language || void 0),
-		TABCLASS: "TRANSP",
-		DDTEXT: obj.description ?? ""
+	toAbapGit: (obj) => ({ SKEY: {
+		TYPE: "BDEF",
+		NAME: String(obj?.name ?? "").toUpperCase()
 	} }),
-	serialize: (obj, ctx) => serializeTabl(obj, ctx),
-	fromAbapGit: fromAbapGitTabl
+	getSource: affGetSource,
+	fromAbapGit: ({ SKEY }) => affFromAbapGit(SKEY),
+	fromAffJson: (json) => affFromAffJson(json, ""),
+	serialize: (object, ctx, options) => serializeDualFormat(object, ctx, options, {
+		typeLabel: "BDEF",
+		sourceExt: "abdl",
+		jsonExt: `${ctx.fileExtension}.json`
+	}),
+	setSources: affSetSources
 });
-const structureHandler = createHandler(AdkStructure, {
-	schema: tabl,
+
+//#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 an `.acds` file.
+* Supports BOTH formats:
+*   - AFF (default): `.srvd.acds` source + `.srvd.json` metadata sidecar
+*   - Legacy XML:    `.srvd.acds` source + `.srvd.xml` metadata
+*
+* File layout (AFF):
+*   src/zui_foo.srvd.acds — service source text
+*   src/zui_foo.srvd.json — ABAP File Formats metadata
+*
+* File layout (legacy):
+*   src/zui_foo.srvd.acds — service source text
+*   src/zui_foo.srvd.xml  — legacy abapGit XML metadata
+*/
+const serviceDefinitionHandler = createHandler("SRVD", {
+	schema: srvd,
 	version: "v1.0.0",
-	serializer: "LCL_OBJECT_TABL",
+	serializer: "LCL_OBJECT_SRVD",
 	serializer_version: "v1.0.0",
-	toAbapGit: (obj) => ({ DD02V: {
-		TABNAME: obj.name ?? "",
-		DDLANGUAGE: isoToSapLang(obj.language || void 0),
-		TABCLASS: "INTTAB",
-		DDTEXT: obj.description ?? ""
+	toAbapGit: (obj) => ({ SKEY: {
+		TYPE: "SRVD",
+		NAME: String(obj?.name ?? "").toUpperCase()
 	} }),
-	serialize: (obj, ctx) => serializeTabl(obj, ctx),
-	fromAbapGit: fromAbapGitTabl
+	getSource: affGetSource,
+	fromAbapGit: ({ SKEY }) => affFromAbapGit(SKEY),
+	fromAffJson: (json) => ({
+		...affFromAffJson(json, ""),
+		sourceOrigin: json?.generalInformation?.sourceOrigin,
+		sourceType: json?.generalInformation?.sourceType
+	}),
+	serialize: (object, ctx, options) => serializeDualFormat(object, ctx, options, {
+		typeLabel: "SRVD",
+		sourceExt: "acds",
+		jsonExt: `${ctx.fileExtension}.json`,
+		extra: { generalInformation: {
+			sourceOrigin: object.sourceOrigin ?? "abapDevelopmentTools",
+			sourceType: object.sourceType ?? "definition"
+		} }
+	}),
+	setSources: affSetSources
+});
+
+//#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 source text.
+* Supports BOTH formats:
+*   - Legacy XML (default): `<name>.srvb.xml` with SKEY + BINDING block
+*   - AFF JSON:             `<name>.srvb.json` with formatVersion + header
+*
+* File layout (legacy):
+*   src/zui_foo.srvb.xml     — metadata only
+*
+* File layout (AFF):
+*   src/zui_foo.srvb.json    — 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() }),
+	fromAffJson: (json) => {
+		const header = json?.header;
+		const binding = json?.binding;
+		return {
+			name: "",
+			description: header?.description,
+			originalLanguage: header?.originalLanguage,
+			abapLanguageVersion: header?.abapLanguageVersion,
+			bindingType: binding?.bindingType,
+			bindingTypeCategory: binding?.bindingTypeCategory,
+			services: binding?.services
+		};
+	},
+	async serialize(object, ctx, options) {
+		const objectName = ctx.getObjectName(object);
+		if (options?.format === "aff") {
+			const bindingType = String(object?.bindingType ?? object?.data?.bindingType ?? "odataV4");
+			const bindingTypeCategory = String(object?.bindingTypeCategory ?? object?.data?.bindingTypeCategory ?? "odata_v4_ui");
+			const services = object?.services ?? object?.data?.services ?? [];
+			const jsonContent = buildAffJson(String(object?.description ?? object?.name ?? ""), String(object?.originalLanguage ?? "en"), object?.abapLanguageVersion, { binding: {
+				bindingType,
+				bindingTypeCategory,
+				...Array.isArray(services) && services.length > 0 ? { services } : {}
+			} });
+			return [ctx.createFile(`${objectName}.${ctx.fileExtension}.json`, jsonContent)];
+		}
+		const xmlContent = ctx.toAbapGitXml(object);
+		return [ctx.createFile(`${objectName}.${ctx.fileExtension}.xml`, xmlContent)];
+	}
 });
 
 //#endregion
-//#region src/lib/handlers/objects/ttyp.ts
+//#region src/lib/handlers/objects/cds-aff-source.ts
+/** Create the shared dual-format source-and-metadata layout used by CDS source types.
+* Supports both AFF JSON (default) and legacy abapGit XML metadata. */
+function createCdsAffSourceHandler(type, options) {
+	const schema = options?.schema ?? bdef;
+	return createHandler(type, {
+		schema,
+		version: "v1.0.0",
+		serializer: `LCL_OBJECT_${type}`,
+		serializer_version: "v1.0.0",
+		toAbapGit: (obj) => ({ SKEY: {
+			TYPE: type,
+			NAME: String(obj?.name ?? "").toUpperCase()
+		} }),
+		getSource: affGetSource,
+		fromAbapGit: ({ SKEY }) => affFromAbapGit(SKEY),
+		fromAffJson: (json) => options?.fromAffJsonExtra ? {
+			...affFromAffJson(json, ""),
+			...options.fromAffJsonExtra(json)
+		} : affFromAffJson(json, ""),
+		setSources: affSetSources,
+		serialize: (object, ctx, opts) => serializeDualFormat(object, ctx, opts, {
+			typeLabel: type,
+			sourceExt: "acds",
+			jsonExt: `${ctx.fileExtension}.json`,
+			extra: options?.serializeExtra?.(object)
+		})
+	});
+}
+
+//#endregion
+//#region src/lib/handlers/objects/dcls.ts
 /**
-* Table Type (TTYP) object handler for abapGit format
+* DCLS (ABAP Data Control Language Source) object handler for abapGit format
 *
-* Maps between abapGit DD40V codes and ADT API enum values.
+* DCLS is source-driven: the semantic content lives in an `.acds` file.
+* Supports BOTH formats:
+*   - AFF (default): `.dcls.acds` source + `.dcls.json` metadata sidecar
+*   - Legacy XML:    `.dcls.acds` source + `.dcls.xml` metadata
 */
-/** 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]));
+const dclSourceHandler = createCdsAffSourceHandler("DCLS", { schema: dcls });
+
+//#endregion
+//#region src/lib/handlers/objects/ddls.ts
 /**
-* DD40V ROWKIND → ADT rowType.typeKind
+* DDLS (Data Definition Language Source) object handler for abapGit format
 *
-* ROWKIND='' (empty) + DATATYPE set → predefinedAbapType (built-in like STRING, INT4)
-* ROWKIND='S' → dictionaryType (references a structure/table/data element)
-* ROWKIND='R' → ref type
+* DDLS is source-driven: the semantic content lives in an `.acds` file.
+* Supports BOTH formats:
+*   - AFF (default): `.ddls.acds` source + `.ddls.json` metadata sidecar
+*   - Legacy XML:    `.ddls.acds` source + `.ddls.xml` metadata
 */
-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]));
+const ddlSourceHandler = createCdsAffSourceHandler("DDLS", {
+	schema: ddls,
+	fromAffJsonExtra: (json) => ({
+		sourceOrigin: json?.sourceOrigin,
+		sourceType: json?.sourceType
+	}),
+	serializeExtra: (object) => ({
+		sourceOrigin: object.sourceOrigin ?? "abapDevelopmentTools",
+		sourceType: object.sourceType ?? "unknown"
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/ddlx.ts
 /**
-* DD40V DATATYPE (DDIC code) → ADT builtInType.dataType (ABAP type name)
+* DDLX (CDS Metadata Extension) object handler for abapGit format
 *
-* 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.
+* DDLX is source-driven: the semantic content lives in an `.acds` file.
+* Supports BOTH formats:
+*   - AFF (default): `.ddlx.acds` source + `.ddlx.json` metadata sidecar
+*   - Legacy XML:    `.ddlx.acds` source + `.ddlx.xml` metadata
 */
-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]));
+const ddlExtensionHandler = createCdsAffSourceHandler("DDLX", { schema: ddlx });
+
+//#endregion
+//#region src/lib/handlers/objects/msag.ts
 /**
-* DD40V TYPELEN — fixed internal byte length for predefined types.
+* MSAG (Message Class) object handler for abapGit format
 *
-* 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).
+* Message classes are XML-only (no source code). The abapGit format stores
+* the class header in T100A and the individual message lines in the T100
+* table (wrapped in <item> elements).
 */
-const FIXED_TYPELEN = {
-	STRG: 8,
-	RSTR: 8
-};
-const tableTypeHandler = createHandler(AdkTableType, {
-	schema: ttyp,
+const messageClassHandler = createHandler("MSAG", {
+	schema: msag,
 	version: "v1.0.0",
-	serializer: "LCL_OBJECT_TTYP",
+	serializer: "LCL_OBJECT_MSAG",
 	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)
-		} };
+		const messages = obj.messages ?? [];
+		return {
+			T100A: {
+				ARBGB: String(obj.name ?? "").toUpperCase(),
+				MASTERLANG: isoToSapLang(obj.masterLanguage || obj.language),
+				STEXT: obj.description ?? ""
+			},
+			T100: messages.length > 0 ? { item: messages.map((m) => ({
+				SPRSL: isoToSapLang(m.language || obj.masterLanguage || obj.language),
+				ARBGB: String(obj.name ?? "").toUpperCase(),
+				MSGNR: String(m.number ?? "").padStart(3, "0"),
+				TEXT: m.text ?? ""
+			})) } : void 0
+		};
 	},
-	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";
+	fromAbapGit: ({ T100A, T100 }) => {
+		const rawItems = T100?.item ?? [];
+		const items = Array.isArray(rawItems) ? rawItems : [rawItems];
 		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: ""
+			name: (T100A?.ARBGB ?? "").toUpperCase(),
+			type: "MSAG/MS",
+			description: T100A?.STEXT,
+			language: sapLangToIso(T100A?.MASTERLANG),
+			masterLanguage: sapLangToIso(T100A?.MASTERLANG),
+			messages: items.map((m) => ({
+				number: m.MSGNR ?? "",
+				text: m.TEXT ?? "",
+				language: sapLangToIso(m.SPRSL)
+			}))
+		};
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/view.ts
+/**
+* VIEW (Database View) object handler for abapGit format
+*
+* Database views are XML-only (no source code). The abapGit format stores
+* the view header in DD25V, table assignments in DD26V_TABLE, view fields
+* in DD27P_TABLE and selection conditions in DD28V_TABLE.
+*/
+const viewHandler = createHandler("VIEW", {
+	schema: view,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_VIEW",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const tables = obj.tables ?? [];
+		const fields = obj.fields ?? [];
+		const conditions = obj.selectionConditions ?? [];
+		return {
+			DD25V: {
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				DDLANGUAGE: isoToSapLang(obj.language),
+				DDTEXT: obj.description ?? "",
+				VIEWCLASS: obj.viewClass ?? void 0,
+				ROOTTAB: obj.baseTable ?? void 0,
+				ROOTFIELD: obj.baseTableField ?? void 0
 			},
-			accessType,
-			primaryKey: {
-				definition: keyDef,
-				kind: keyKind,
-				components: { component: [] },
-				alias: ""
+			DD26V_TABLE: tables.length > 0 ? { item: tables.map((t) => ({
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				TABNAME: t.tableName ?? void 0,
+				TABPOS: t.position ?? void 0,
+				FVIEWNAME: t.foreignView ?? void 0,
+				FFIELDNAME: t.foreignField ?? void 0,
+				READONLY: t.readOnly ? "X" : void 0
+			})) } : void 0,
+			DD27P_TABLE: fields.length > 0 ? { item: fields.map((f) => ({
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				VIEWFIELD: f.viewField ?? void 0,
+				TABNAME: f.tableName ?? void 0,
+				FIELDNAME: f.fieldName ?? void 0,
+				KEYFLAG: f.keyFlag ? "X" : void 0,
+				READONLY: f.readOnly ? "X" : void 0,
+				ROLLNAME: f.rollName ?? void 0,
+				CHECKTABLE: f.checkTable ?? void 0,
+				DDTEXT: f.description ?? void 0
+			})) } : void 0,
+			DD28V_TABLE: conditions.length > 0 ? { item: conditions.map((c) => ({
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				ANDOR: c.andOr ?? void 0,
+				LEFTBRACKET: c.leftBracket ?? void 0,
+				FIELDNAME: c.fieldName ?? void 0,
+				OPERATOR: c.operator ?? void 0,
+				CONST_VALUE: c.constantValue ?? void 0,
+				RIGHTBRACKET: c.rightBracket ?? void 0
+			})) } : void 0
+		};
+	},
+	fromAbapGit: parseViewFromAbapGit
+});
+function normalizeItems$3(raw) {
+	if (!raw) return [];
+	return Array.isArray(raw) ? raw : [raw];
+}
+function parseViewTable(t) {
+	return {
+		tableName: t.TABNAME,
+		position: t.TABPOS,
+		foreignView: t.FVIEWNAME,
+		foreignField: t.FFIELDNAME,
+		readOnly: t.READONLY === "X"
+	};
+}
+function parseViewField(f) {
+	return {
+		viewField: f.VIEWFIELD,
+		tableName: f.TABNAME,
+		fieldName: f.FIELDNAME,
+		keyFlag: f.KEYFLAG === "X",
+		readOnly: f.READONLY === "X",
+		rollName: f.ROLLNAME,
+		checkTable: f.CHECKTABLE,
+		description: f.DDTEXT
+	};
+}
+function parseViewCondition(c) {
+	return {
+		andOr: c.ANDOR,
+		leftBracket: c.LEFTBRACKET,
+		fieldName: c.FIELDNAME,
+		operator: c.OPERATOR,
+		constantValue: c.CONST_VALUE,
+		rightBracket: c.RIGHTBRACKET
+	};
+}
+function parseViewFromAbapGit({ DD25V, DD26V_TABLE, DD27P_TABLE, DD28V_TABLE }) {
+	const tableItems = normalizeItems$3(DD26V_TABLE?.item);
+	const fieldItems = normalizeItems$3(DD27P_TABLE?.item);
+	const condItems = normalizeItems$3(DD28V_TABLE?.item);
+	return {
+		name: (DD25V?.VIEWNAME ?? "").toUpperCase(),
+		type: "VIEW/VD",
+		description: DD25V?.DDTEXT,
+		language: sapLangToIso(DD25V?.DDLANGUAGE),
+		masterLanguage: sapLangToIso(DD25V?.DDLANGUAGE),
+		viewClass: DD25V?.VIEWCLASS,
+		baseTable: DD25V?.ROOTTAB,
+		baseTableField: DD25V?.ROOTFIELD,
+		tables: tableItems.map(parseViewTable),
+		fields: fieldItems.map(parseViewField),
+		selectionConditions: condItems.map(parseViewCondition)
+	};
+}
+
+//#endregion
+//#region src/lib/handlers/objects/enqu.ts
+/**
+* ENQU (Lock Object) object handler for abapGit format
+*
+* Lock objects are XML-only (no source code). The abapGit format stores
+* the lock object header in DD25V, table assignments in DD26V_TABLE and
+* lock parameters in DD27P_TABLE.
+*/
+const lockObjectHandler = createHandler("ENQU", {
+	schema: enqu,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_ENQU",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const tables = obj.tables ?? [];
+		const parameters = obj.parameters ?? [];
+		return {
+			DD25V: {
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				DDLANGUAGE: isoToSapLang(obj.masterLanguage || obj.language),
+				DDTEXT: obj.description ?? "",
+				ROOTTAB: obj.baseTable ?? void 0,
+				ROOTFIELD: obj.baseTableField ?? void 0
 			},
-			secondaryKeys: { allowed: "notSpecified" }
+			DD26V_TABLE: tables.length > 0 ? { item: tables.map((t) => ({
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				TABNAME: t.tableName ?? void 0,
+				TABPOS: t.position ?? void 0,
+				FVIEWNAME: t.foreignView ?? void 0,
+				FFIELDNAME: t.foreignField ?? void 0,
+				READONLY: t.readOnly ? "X" : void 0
+			})) } : void 0,
+			DD27P_TABLE: parameters.length > 0 ? { item: parameters.map((p) => ({
+				VIEWNAME: String(obj.name ?? "").toUpperCase(),
+				VIEWFIELD: p.viewField ?? void 0,
+				TABNAME: p.tableName ?? void 0,
+				FIELDNAME: p.fieldName ?? void 0,
+				KEYFLAG: p.keyFlag ? "X" : void 0,
+				ROLLNAME: p.rollName ?? void 0,
+				CHECKTABLE: p.checkTable ?? void 0,
+				DDTEXT: p.description ?? void 0
+			})) } : void 0
 		};
-	}
+	},
+	fromAbapGit: parseLockObjectFromAbapGit
 });
+function normalizeItems$2(raw) {
+	if (!raw) return [];
+	return Array.isArray(raw) ? raw : [raw];
+}
+function parseEnquTable(t) {
+	return {
+		tableName: t.TABNAME,
+		position: t.TABPOS,
+		foreignView: t.FVIEWNAME,
+		foreignField: t.FFIELDNAME,
+		readOnly: t.READONLY === "X"
+	};
+}
+function parseEnquParam(p) {
+	return {
+		viewField: p.VIEWFIELD,
+		tableName: p.TABNAME,
+		fieldName: p.FIELDNAME,
+		keyFlag: p.KEYFLAG === "X",
+		rollName: p.ROLLNAME,
+		checkTable: p.CHECKTABLE,
+		description: p.DDTEXT
+	};
+}
+function parseLockObjectFromAbapGit({ DD25V, DD26V_TABLE, DD27P_TABLE }) {
+	const tableItems = normalizeItems$2(DD26V_TABLE?.item);
+	const paramItems = normalizeItems$2(DD27P_TABLE?.item);
+	return {
+		name: (DD25V?.VIEWNAME ?? "").toUpperCase(),
+		type: "ENQU/LO",
+		description: DD25V?.DDTEXT,
+		language: sapLangToIso(DD25V?.DDLANGUAGE),
+		masterLanguage: sapLangToIso(DD25V?.DDLANGUAGE),
+		baseTable: DD25V?.ROOTTAB,
+		baseTableField: DD25V?.ROOTFIELD,
+		tables: tableItems.map(parseEnquTable),
+		parameters: paramItems.map(parseEnquParam)
+	};
+}
 
 //#endregion
-//#region src/lib/handlers/objects/bdef.ts
+//#region src/lib/handlers/objects/shlp.ts
 /**
-* BDEF (RAP Behavior Definition) object handler for abapGit format
+* SHLP (Search Help) 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.
+* Search helps are XML-only (no source code). The abapGit format stores
+* the search help header in DD30V, the text table info in DD31V,
+* parameters in DD32P_TABLE and field assignments in DD33V_TABLE.
+*/
+const searchHelpHandler = createHandler("SHLP", {
+	schema: shlp,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_SHLP",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => {
+		const parameters = obj.parameters ?? [];
+		const assignments = obj.fieldAssignments ?? [];
+		return {
+			DD30V: {
+				SHLPNAME: String(obj.name ?? "").toUpperCase(),
+				DDLANGUAGE: isoToSapLang(obj.language),
+				DDTEXT: obj.description ?? "",
+				SHLPTYPE: obj.helpType ?? void 0,
+				DIALOGTYPE: obj.dialogType ?? void 0
+			},
+			DD31V: obj.textTable ? {
+				SHLPNAME: String(obj.name ?? "").toUpperCase(),
+				TABNAME: obj.textTable.tableName ?? void 0,
+				FIELDNAME: obj.textTable.fieldName ?? void 0,
+				FLDLOCATION: obj.textTable.fieldLocation ?? void 0,
+				ROLLNAME: obj.textTable.rollName ?? void 0
+			} : void 0,
+			DD32P_TABLE: parameters.length > 0 ? { item: parameters.map((p) => ({
+				SHLPNAME: String(obj.name ?? "").toUpperCase(),
+				FIELDNAME: p.fieldName ?? void 0,
+				SHLPINPUT: p.input ? "X" : void 0,
+				SHLPOUTPUT: p.output ? "X" : void 0,
+				SHLPSELPOS: p.selectionPosition ?? void 0,
+				SHLPLISPOS: p.listPosition ?? void 0,
+				DEFAULTVAL: p.defaultValue ?? void 0,
+				ROLLNAME: p.rollName ?? void 0,
+				DDTEXT: p.description ?? void 0
+			})) } : void 0,
+			DD33V_TABLE: assignments.length > 0 ? { item: assignments.map((a) => ({
+				SHLPNAME: String(obj.name ?? "").toUpperCase(),
+				SHLPFIELD: a.helpField ?? void 0,
+				TABNAME: a.tableName ?? void 0,
+				FIELDNAME: a.fieldName ?? void 0,
+				SHLPINPUT: a.input ? "X" : void 0,
+				SHLPOUTPUT: a.output ? "X" : void 0
+			})) } : void 0
+		};
+	},
+	fromAbapGit: parseSearchHelpFromAbapGit
+});
+function normalizeItems$1(raw) {
+	if (!raw) return [];
+	return Array.isArray(raw) ? raw : [raw];
+}
+function parseShlpParam(p) {
+	return {
+		fieldName: p.FIELDNAME,
+		input: p.SHLPINPUT === "X",
+		output: p.SHLPOUTPUT === "X",
+		selectionPosition: p.SHLPSELPOS,
+		listPosition: p.SHLPLISPOS,
+		defaultValue: p.DEFAULTVAL,
+		rollName: p.ROLLNAME,
+		description: p.DDTEXT
+	};
+}
+function parseShlpAssign(a) {
+	return {
+		helpField: a.SHLPFIELD,
+		tableName: a.TABNAME,
+		fieldName: a.FIELDNAME,
+		input: a.SHLPINPUT === "X",
+		output: a.SHLPOUTPUT === "X"
+	};
+}
+function parseSearchHelpFromAbapGit({ DD30V, DD31V, DD32P_TABLE, DD33V_TABLE }) {
+	const paramItems = normalizeItems$1(DD32P_TABLE?.item);
+	const assignItems = normalizeItems$1(DD33V_TABLE?.item);
+	return {
+		name: (DD30V?.SHLPNAME ?? "").toUpperCase(),
+		type: "SHLP/SH",
+		description: DD30V?.DDTEXT,
+		language: sapLangToIso(DD30V?.DDLANGUAGE),
+		masterLanguage: sapLangToIso(DD30V?.DDLANGUAGE),
+		helpType: DD30V?.SHLPTYPE,
+		dialogType: DD30V?.DIALOGTYPE,
+		textTable: DD31V ? {
+			tableName: DD31V.TABNAME,
+			fieldName: DD31V.FIELDNAME,
+			fieldLocation: DD31V.FLDLOCATION,
+			rollName: DD31V.ROLLNAME
+		} : void 0,
+		parameters: paramItems.map(parseShlpParam),
+		fieldAssignments: assignItems.map(parseShlpAssign)
+	};
+}
+
+//#endregion
+//#region src/lib/handlers/objects/tran.ts
+/**
+* TRAN (Transaction) object handler for abapGit format
 *
-* File layout:
-*   src/zbp_foo.bdef.abdl   — behavior source (.abdl text)
-*   src/zbp_foo.bdef.xml    — minimal metadata wrapper
+* Transactions are XML-only (no source code). The abapGit format stores
+* the transaction code in TSTC, GUI attributes in TSTCC and texts in
+* the TSTCT table (wrapped in <item> elements).
+*/
+const transactionHandler = createHandler("TRAN", {
+	schema: tran,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_TRAN",
+	serializer_version: "v1.0.0",
+	toAbapGit: buildTransactionToAbapGit,
+	fromAbapGit: parseTransactionFromAbapGit
+});
+function normalizeItems(raw) {
+	if (!raw) return [];
+	return Array.isArray(raw) ? raw : [raw];
+}
+function parseGuiAttributes(TSTCC) {
+	if (!TSTCC) return void 0;
+	return {
+		webGui: TSTCC.S_WEBGUI === "X",
+		platinumGui: TSTCC.S_PLATIN === "X",
+		win32Gui: TSTCC.S_WIN32 === "X",
+		macGui: TSTCC.S_MAC === "X"
+	};
+}
+function parseTransactionFromAbapGit({ TSTC, TSTCC, TSTCT }) {
+	const textItems = normalizeItems(TSTCT?.item);
+	const firstText = textItems[0];
+	return {
+		name: (TSTC?.TCODE ?? "").toUpperCase(),
+		type: "TRAN/ST",
+		description: firstText?.TTEXT,
+		language: sapLangToIso(firstText?.SPRSL),
+		masterLanguage: sapLangToIso(firstText?.SPRSL),
+		programName: TSTC?.PGMNA,
+		dynproNumber: TSTC?.DYPNO,
+		transactionType: TSTC?.TYPE,
+		guiAttributes: parseGuiAttributes(TSTCC),
+		texts: textItems.map((t) => ({
+			language: sapLangToIso(t.SPRSL),
+			text: t.TTEXT
+		}))
+	};
+}
+function buildTstc(obj) {
+	return {
+		TCODE: String(obj.name ?? "").toUpperCase(),
+		PGMNA: obj.programName ?? void 0,
+		DYPNO: obj.dynproNumber ?? void 0,
+		TYPE: obj.transactionType ?? void 0
+	};
+}
+function buildTstcc(gui, tcode) {
+	return {
+		TCODE: tcode,
+		S_WEBGUI: gui.webGui ? "X" : void 0,
+		S_PLATIN: gui.platinumGui ? "X" : void 0,
+		S_WIN32: gui.win32Gui ? "X" : void 0,
+		S_MAC: gui.macGui ? "X" : void 0
+	};
+}
+function buildTstct(texts, obj) {
+	if (texts.length === 0) return void 0;
+	return { item: texts.map((t) => ({
+		SPRSL: isoToSapLang(t.language || obj.masterLanguage || obj.language),
+		TCODE: String(obj.name ?? "").toUpperCase(),
+		TTEXT: t.text ?? ""
+	})) };
+}
+function buildTransactionToAbapGit(obj) {
+	const texts = obj.texts ?? [];
+	const tcode = String(obj.name ?? "").toUpperCase();
+	return {
+		TSTC: buildTstc(obj),
+		TSTCC: obj.guiAttributes ? buildTstcc(obj.guiAttributes, tcode) : void 0,
+		TSTCT: buildTstct(texts, obj)
+	};
+}
+
+//#endregion
+//#region src/lib/handlers/objects/type.ts
+/**
+* TYPE (Type Group / Type Pool) object handler for abapGit format
 *
-* 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.
+* Type groups have both XML metadata (TYPE structure) and ABAP source
+* (<name>.type.abap). The abapGit format stores the header in TYPE.
+*/
+const typeGroupHandler = createHandler("TYPE", {
+	schema: type,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_TYPE",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ TYPE: {
+		TYPEGROUP: String(obj.name ?? "").toUpperCase(),
+		DESCRIPT: obj.description ?? ""
+	} }),
+	getSource: (obj) => typeof obj?.getSource === "function" ? Promise.resolve(obj.getSource()) : Promise.resolve(""),
+	fromAbapGit: ({ TYPE }) => ({
+		name: (TYPE?.TYPEGROUP ?? "").toUpperCase(),
+		type: "TYPE/TY",
+		description: TYPE?.DESCRIPT
+	}),
+	setSources: (obj, sources) => {
+		if (sources.main) obj._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/xslt.ts
+/**
+* XSLT (Transformation) object handler for abapGit format
 *
-* We override `serialize` so the source file gets the `.abdl` extension
-* instead of the default `.abap`.
+* Transformations have both XML metadata (XSLT structure) and ABAP source
+* (<name>.xslt.abap). The abapGit format stores the header in XSLT.
 */
-const behaviorDefinitionHandler = createHandler("BDEF", {
+const transformationHandler = createHandler("XSLT", {
+	schema: xslt,
+	version: "v1.0.0",
+	serializer: "LCL_OBJECT_XSLT",
+	serializer_version: "v1.0.0",
+	toAbapGit: (obj) => ({ XSLT: {
+		PROGNAME: String(obj.name ?? "").toUpperCase(),
+		DESCRIPT: obj.description ?? ""
+	} }),
+	getSource: (obj) => typeof obj?.getSource === "function" ? Promise.resolve(obj.getSource()) : Promise.resolve(""),
+	fromAbapGit: ({ XSLT }) => ({
+		name: (XSLT?.PROGNAME ?? "").toUpperCase(),
+		type: "XSLT/TX",
+		description: XSLT?.DESCRIPT
+	}),
+	setSources: (obj, sources) => {
+		if (sources.main) obj._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/dras.ts
+const cdsAspectHandler = createCdsAffSourceHandler("DRAS");
+
+//#endregion
+//#region src/lib/handlers/objects/drty.ts
+const cdsTypeHandler = createCdsAffSourceHandler("DRTY");
+
+//#endregion
+//#region src/lib/handlers/objects/dsfd.ts
+const scalarFunctionDefinitionHandler = createCdsAffSourceHandler("DSFD");
+
+//#endregion
+//#region src/lib/handlers/objects/dsfi.ts
+const VALID_ENGINES = /* @__PURE__ */ new Set(["analyticalEngine", "sqlEngine"]);
+function isDsfiDefinition(value) {
+	const candidate = value;
+	return !!candidate && candidate.formatVersion === "1" && typeof candidate.scalarFunctionName === "string" && VALID_ENGINES.has(candidate.engine ?? "") && typeof candidate.header?.description === "string" && typeof candidate.header?.originalLanguage === "string";
+}
+function parseDsfiDefinition(value) {
+	let parsed;
+	try {
+		parsed = typeof value === "string" ? JSON.parse(value) : value;
+	} catch {
+		throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", "DSFI source/main did not return valid JSON.");
+	}
+	if (!isDsfiDefinition(parsed)) throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", "DSFI source/main did not return the required ABAP File Format JSON document.");
+	return parsed;
+}
+const scalarFunctionImplementationHandler = createHandler("DSFI", {
 	schema: bdef,
 	version: "v1.0.0",
-	serializer: "LCL_OBJECT_BDEF",
+	serializer: "LCL_OBJECT_DSFI",
 	serializer_version: "v1.0.0",
 	toAbapGit: (obj) => ({ SKEY: {
-		TYPE: "BDEF",
+		TYPE: "DSFI",
 		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;
+	fromAffJson: (json) => {
+		const def = json;
+		return {
+			name: "",
+			description: def?.header?.description,
+			originalLanguage: def?.header?.originalLanguage,
+			abapLanguageVersion: def?.header?.abapLanguageVersion
+		};
 	},
-	setSources: (obj, sources) => {
-		if (sources.main) obj._pendingSource = sources.main;
+	async serialize(object, ctx) {
+		const definition = parseDsfiDefinition(typeof object.getSource === "function" ? await object.getSource() : void 0);
+		return [ctx.createFile(`${ctx.getObjectName(object)}.dsfi.json`, `${JSON.stringify(definition, null, 2)}\n`)];
 	}
 });
 
 //#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,
+//#region src/lib/handlers/objects/dteb.ts
+const entityBufferHandler = createCdsAffSourceHandler("DTEB");
+
+//#endregion
+//#region src/lib/handlers/objects/dtdc.ts
+const dynamicCacheHandler = createCdsAffSourceHandler("DTDC");
+
+//#endregion
+//#region src/lib/handlers/objects/dtix.ts
+const tuningIndexHandler = createCdsAffSourceHandler("DTIX");
+
+//#endregion
+//#region src/lib/handlers/objects/dtsc.ts
+const staticCacheHandler = createCdsAffSourceHandler("DTSC");
+
+//#endregion
+//#region src/lib/handlers/objects/desd.ts
+const externalSchemaHandler = createHandler("DESD", {
+	schema: bdef,
 	version: "v1.0.0",
-	serializer: "LCL_OBJECT_SRVD",
+	serializer: "LCL_OBJECT_DESD",
 	serializer_version: "v1.0.0",
 	toAbapGit: (obj) => ({ SKEY: {
-		TYPE: "SRVD",
+		TYPE: "DESD",
 		NAME: String(obj?.name ?? "").toUpperCase()
 	} }),
-	getSource: (obj) => typeof obj?.getSource === "function" ? obj.getSource() : Promise.resolve(""),
-	fromAbapGit: ({ SKEY }) => ({ name: String(SKEY?.NAME ?? "").toUpperCase() }),
+	fromAffJson: (json) => affFromAffJson(json, ""),
 	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;
+		const header = {
+			description: object.description || String(object.name ?? ""),
+			originalLanguage: (object.originalLanguage ?? "en").toLowerCase()
+		};
+		return [ctx.createFile(`${ctx.getObjectName(object)}.desd.json`, `${JSON.stringify({
+			formatVersion: "1",
+			header
+		}, null, 2)}\n`)];
 	}
 });
 
 //#endregion
-//#region src/lib/handlers/objects/srvb.ts
+//#region src/lib/handlers/aff-handler.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.
+* Shared factory for AFF-first object handlers.
 *
-* File layout:
-*   src/zui_foo.srvb.xml     — metadata only
+* The 17 AFF-first types (APLO, BGQC, CDBO, CHKC, CHKO, CHKV, COTA, EVTB,
+* GSMP, NONT, RONT, SAJC, SAJT, SMBC, UIAD, UIPG, UIST) all share the same
+* serialization logic — only the type code and file extension differ.
+* This factory eliminates the per-handler duplication.
+*/
+/**
+* Create an AFF-first handler that serializes to JSON metadata only.
 *
-* Mirrors the minimal-block approach used by
-* zcl_abapgit_object_srvb (abapGit upstream serialiser).
+* @param type    ABAP object type code (e.g. 'APLO')
+* @param ext     Lowercase file extension for the JSON sidecar (e.g. 'aplo')
 */
-const serviceBindingHandler = createHandler("SRVB", {
-	schema: srvb,
-	version: "v1.0.0",
-	serializer: "LCL_OBJECT_SRVB",
-	serializer_version: "v1.0.0",
-	toAbapGit: (obj) => ({
-		SKEY: {
-			TYPE: "SRVB",
+function createAffFirstHandler(type, ext) {
+	return createHandler(type, {
+		schema: bdef,
+		version: "v1.0.0",
+		serializer: `LCL_OBJECT_${type}`,
+		serializer_version: "v1.0.0",
+		toAbapGit: (obj) => ({ SKEY: {
+			TYPE: type,
 			NAME: String(obj?.name ?? "").toUpperCase()
-		},
-		BINDING: {
-			TYPE: "odataV4",
-			VERSION: "4",
-			CATEGORY: "odata_v4_ui"
+		} }),
+		fromAffJson: (json) => affFromAffJson(json, ""),
+		async serialize(object, ctx) {
+			const header = {
+				description: object.description || String(object.name ?? ""),
+				originalLanguage: (object.originalLanguage ?? "en").toLowerCase()
+			};
+			return [ctx.createFile(`${ctx.getObjectName(object)}.${ext}.json`, `${JSON.stringify({
+				formatVersion: "1",
+				header
+			}, null, 2)}\n`)];
 		}
-	}),
-	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/handlers/objects/aplo.ts
+const applicationLogObjectHandler = createAffFirstHandler("APLO", "aplo");
+
+//#endregion
+//#region src/lib/handlers/objects/bgqc.ts
+const bgqcHandler = createAffFirstHandler("BGQC", "bgqc");
+
+//#endregion
+//#region src/lib/handlers/objects/cdbo.ts
+const cdboHandler = createAffFirstHandler("CDBO", "cdbo");
+
+//#endregion
+//#region src/lib/handlers/objects/chkc.ts
+const checkCategoryHandler = createAffFirstHandler("CHKC", "chkc");
+
+//#endregion
+//#region src/lib/handlers/objects/chko.ts
+const checkObjectHandler = createAffFirstHandler("CHKO", "chko");
+
+//#endregion
+//#region src/lib/handlers/objects/chkv.ts
+const checkVariantHandler = createAffFirstHandler("CHKV", "chkv");
+
+//#endregion
+//#region src/lib/handlers/objects/cota.ts
+const communicationTargetHandler = createAffFirstHandler("COTA", "cota");
+
+//#endregion
+//#region src/lib/handlers/objects/evtb.ts
+const eventBindingHandler = createAffFirstHandler("EVTB", "evtb");
+
+//#endregion
+//#region src/lib/handlers/objects/gsmp.ts
+const gsmpHandler = createAffFirstHandler("GSMP", "gsmp");
+
+//#endregion
+//#region src/lib/handlers/objects/nont.ts
+const objectTypeNodeHandler = createAffFirstHandler("NONT", "nont");
+
+//#endregion
+//#region src/lib/handlers/objects/ront.ts
+const objectTypeHandler = createAffFirstHandler("RONT", "ront");
+
+//#endregion
+//#region src/lib/handlers/objects/sajc.ts
+const jobCatalogHandler = createAffFirstHandler("SAJC", "sajc");
+
+//#endregion
+//#region src/lib/handlers/objects/sajt.ts
+const jobTemplateHandler = createAffFirstHandler("SAJT", "sajt");
+
+//#endregion
+//#region src/lib/handlers/objects/smbc.ts
+const bcmHandler = createAffFirstHandler("SMBC", "smbc");
+
+//#endregion
+//#region src/lib/handlers/objects/uiad.ts
+const launchpadAppDescriptorHandler = createAffFirstHandler("UIAD", "uiad");
+
+//#endregion
+//#region src/lib/handlers/objects/uipg.ts
+const launchpadPageTemplateHandler = createAffFirstHandler("UIPG", "uipg");
+
+//#endregion
+//#region src/lib/handlers/objects/uist.ts
+const launchpadSpaceTemplateHandler = createAffFirstHandler("UIST", "uist");
 
 //#endregion
 //#region src/lib/folder-logic.ts
@@ -4034,29 +6685,180 @@ function generateAbapGitXml(folderLogic) {
 }
 
 //#endregion
-//#region src/lib/deserializer.ts
+//#region src/lib/filename-parser.ts
+/**
+* abapGit filename parsing utilities.
+*
+* Extracted into a standalone module so it can be unit-tested without
+* pulling in the full handler/schema dependency chain.
+*/
 /**
 * abapGit file naming convention:
 * - XML metadata: {name}.{type}.xml (e.g., zcl_myclass.clas.xml)
+* - AFF JSON metadata: {name}.{type}.json (e.g., zfoo.bdef.json)
 * - Source code: {name}.{type}.abap (e.g., zcl_myclass.clas.abap)
 * - Source includes: {name}.{type}.{suffix}.abap (e.g., zcl_myclass.clas.testclasses.abap)
+* - AFF source files: {name}.{type}.abdl, {name}.{type}.acds, {name}.{type}.asrvd
 */
 /**
 * Parse abapGit filename to extract object info
+*
+* Supports both legacy XML metadata (.xml) and AFF JSON metadata (.json),
+* plus source file extensions (.abap, .abdl, .acds, .asrvd).
 */
 function parseAbapGitFilename(filename) {
-	const match = filename.match(/^([^.]+)\.([^.]+)(?:\.([^.]+))?\.(\w+)$/);
+	const match = filename.match(/^([^.]+)\.([^.]+)(?:\.([^.]+))?\.(xml|json|abap|abdl|acds|asrvd)$/);
 	if (!match) return null;
 	const [, name, type, suffixOrExt, extension] = match;
-	if (extension === "xml" || extension === "abap") return {
+	return {
 		name: name.toUpperCase(),
 		type: type.toUpperCase(),
 		suffix: suffixOrExt && suffixOrExt !== extension ? suffixOrExt : void 0,
 		extension
 	};
+}
+
+//#endregion
+//#region src/lib/deserializer.ts
+/**
+* abapGit file naming convention:
+* - XML metadata: {name}.{type}.xml (e.g., zcl_myclass.clas.xml)
+* - AFF JSON metadata: {name}.{type}.json (e.g., zfoo.bdef.json)
+* - Source code: {name}.{type}.abap (e.g., zcl_myclass.clas.abap)
+* - Source includes: {name}.{type}.{suffix}.abap (e.g., zcl_myclass.clas.testclasses.abap)
+* - AFF source files: {name}.{type}.abdl, {name}.{type}.acds, {name}.{type}.asrvd
+*/
+/**
+* Resolve folder logic and start dir from .abapgit.xml
+*/
+async function resolveFolderConfig(fileTree) {
+	let folderLogic = "prefix";
+	let startDir = "";
+	const hasAbapGitXml = await fileTree.exists(".abapgit.xml");
+	if (hasAbapGitXml) try {
+		const xml = await fileTree.read(".abapgit.xml");
+		const meta = parseAbapGitMetadata(xml);
+		folderLogic = meta.folderLogic;
+		startDir = stripSlashes(meta.startingFolder);
+	} catch {}
+	return {
+		folderLogic,
+		startDir,
+		hasAbapGitXml
+	};
+}
+/**
+* Parse a metadata file path into an object key and register it in the map.
+*/
+function registerMetadataFile(path, supportedTypes, objectMap, field) {
+	const filename = path.slice(path.lastIndexOf("/") + 1);
+	const parsed = parseAbapGitFilename(filename);
+	if (!parsed) return;
+	if (!supportedTypes.has(parsed.type.toLowerCase())) return;
+	if (parsed.suffix) return;
+	const key = `${parsed.name}:${parsed.type}`;
+	if (!objectMap.has(key)) objectMap.set(key, {
+		name: parsed.name,
+		type: parsed.type,
+		sourceFiles: []
+	});
+	objectMap.get(key)[field] = path;
+}
+/**
+* Collect all source files and attach them to their objects in the map.
+*/
+async function collectSourceFiles(fileTree, objectMap) {
+	const [abapFiles, abdlFiles, acdsFiles, asrvdFiles] = await Promise.all([
+		fileTree.glob("**/*.abap"),
+		fileTree.glob("**/*.abdl"),
+		fileTree.glob("**/*.acds"),
+		fileTree.glob("**/*.asrvd")
+	]);
+	for (const sourcePath of [
+		...abapFiles,
+		...abdlFiles,
+		...acdsFiles,
+		...asrvdFiles
+	]) {
+		const filename = sourcePath.slice(sourcePath.lastIndexOf("/") + 1);
+		const parsed = parseAbapGitFilename(filename);
+		if (!parsed) continue;
+		const obj = objectMap.get(`${parsed.name}:${parsed.type}`);
+		if (obj) obj.sourceFiles.push({
+			path: sourcePath,
+			suffix: parsed.suffix
+		});
+	}
+}
+/**
+* Parse metadata (XML or JSON) and return values + isAffJson flag.
+*/
+async function parseMetadata(fileTree, objFiles, handler) {
+	if (objFiles.jsonFile) {
+		const jsonContent = await fileTree.read(objFiles.jsonFile);
+		let jsonData;
+		try {
+			jsonData = JSON.parse(jsonContent);
+		} catch (parseError) {
+			console.error(`Failed to parse AFF JSON ${objFiles.jsonFile}:`, parseError);
+			return null;
+		}
+		return {
+			values: handler?.fromAffJson ? handler.fromAffJson(jsonData) : jsonData,
+			isAffJson: true
+		};
+	}
+	if (objFiles.xmlFile) {
+		const xmlContent = await fileTree.read(objFiles.xmlFile);
+		return {
+			values: handler.schema.parse(xmlContent)?.abapGit?.abap?.values ?? {},
+			isAffJson: false
+		};
+	}
 	return null;
 }
 /**
+* Build the payload from handler or filename fallback.
+*/
+function buildPayload(handler, values, isAffJson, objFiles) {
+	if (isAffJson && handler?.fromAffJson) return values;
+	if (isAffJson) return { name: objFiles.name };
+	if (handler?.fromAbapGit) return handler.fromAbapGit(values);
+	return { name: objFiles.name };
+}
+/**
+* Set sources on an ADK object using handler or fallback.
+*/
+function setObjectSources(handler, adkObject, sources) {
+	if (Object.keys(sources).length === 0) return;
+	if (handler?.setSources) {
+		handler.setSources(adkObject, sources);
+		return;
+	}
+	if (sources["main"]) adkObject._pendingSource = sources["main"];
+	if (Object.keys(sources).length > 1) adkObject._pendingSources = sources;
+}
+/**
+* Resolve packageRef on an ADK object from folder logic or rootPackage.
+*/
+function resolvePackageRef(adkObject, options, hasAbapGitXml, folderLogic) {
+	if (!options?.rootPackage) return;
+	const data = adkObject._data;
+	if (!data || data.packageRef) return;
+	if (hasAbapGitXml) {
+		const relDir = adkObject._relDir ?? "";
+		data.packageRef = { name: resolvePackageFromDir(relDir, folderLogic, options.rootPackage) };
+	} else data.packageRef = { name: options.rootPackage };
+}
+/**
+* Set abapLanguageVersion on an ADK object if provided in options.
+*/
+function setAbapLanguageVersion(adkObject, options) {
+	if (!options?.abapLanguageVersion) return;
+	const data = adkObject._data;
+	if (data && !data.abapLanguageVersion) data.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
+}
+/**
 * Deserialize abapGit files to ADK objects
 *
 * True generator - yields objects one at a time as they're discovered.
@@ -4068,119 +6870,131 @@ function parseAbapGitFilename(filename) {
 */
 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 { folderLogic, startDir, hasAbapGitXml } = await resolveFolderConfig(fileTree);
+	const [xmlFiles, jsonFiles] = await Promise.all([fileTree.glob("**/*.xml"), fileTree.glob("**/*.json")]);
 	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
-		});
+		registerMetadataFile(xmlPath, supportedTypes, objectMap, "xmlFile");
 	}
+	for (const jsonPath of jsonFiles) registerMetadataFile(jsonPath, supportedTypes, objectMap, "jsonFile");
+	await collectSourceFiles(fileTree, objectMap);
 	for (const [, objFiles] of objectMap) {
-		if (!objFiles.xmlFile) continue;
+		if (!objFiles.xmlFile && !objFiles.jsonFile) 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 meta = await parseMetadata(fileTree, objFiles, handler);
+			if (!meta) continue;
+			const { values, isAffJson } = meta;
 			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 payload = buildPayload(handler, values, isAffJson, objFiles);
 			const objectName = payload.name || objFiles.name;
-			const fullData = {
+			const adkType = typeof payload.type === "string" ? payload.type : objFiles.type;
+			const adkObject = adk.getWithData({
 				...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;
-			}
+			}, adkType);
+			setObjectSources(handler, adkObject, sources);
 			if (payload.description) adkObject._pendingDescription = payload.description;
 			if (hasAbapGitXml) {
-				const sourceDir = objFiles.xmlFile.split("/").slice(0, -1).join("/");
+				const sourceDir = (objFiles.xmlFile ?? objFiles.jsonFile ?? "").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;
-			}
+			resolvePackageRef(adkObject, options, hasAbapGitXml, folderLogic);
+			setAbapLanguageVersion(adkObject, options);
 			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);
-				}
-			}
+			if (objFiles.type === "FUGR" && payload._functions) yield* yieldFugrChildren(adk, payload, objectName, options, adkObject);
 		} catch (error) {
 			console.error(`Failed to deserialize ${objFiles.type} ${objFiles.name}:`, error);
 		}
 	}
 }
+/**
+* Yield FUGR child function modules as separate ADK objects.
+*/
+async function* yieldFugrChildren(adk, payload, parentName, options, parentObject) {
+	const fmDescriptors = extractFunctionDescriptors(payload._functions);
+	const fmSources = parentObject._pendingFmSources;
+	for (const fm of fmDescriptors) try {
+		const fmObject = adk.getWithData({
+			name: fm.funcName,
+			type: "FUGR/FF",
+			_groupName: parentName,
+			description: fm.shortText ?? "",
+			processingType: fm.processingType,
+			basXMLEnabled: fm.basXMLEnabled
+		}, "FUGR/FF");
+		const fmSource = fmSources?.[fm.funcName.toLowerCase()];
+		if (fmSource) fmObject._pendingSource = fmSource;
+		setAbapLanguageVersion(fmObject, options);
+		yield fmObject;
+	} catch (fmError) {
+		console.error(`Failed to deserialize FM ${fm.funcName} in FUGR ${parentName}:`, fmError);
+	}
+}
 
 //#endregion
 //#region src/lib/format-plugin.ts
+/**
+* abapGit as a FormatPlugin.
+*
+* This is the thin adapter that plugs the abapGit handler registry into the
+* generic `FormatPlugin` contract defined by `@abapify/adt-plugin`. External
+* consumers (adt-export, adt-diff, adt-cli) interact with this plugin
+* **through the registry only** — they look it up with
+* `getFormatPlugin('abapgit')` and never import this package directly.
+*
+* Registration happens as a side-effect of importing `@abapify/adt-plugin-abapgit`;
+* the CLI bootstraps the registration once in `adt-cli/src/lib/cli.ts`.
+*/
+function classifyFile(parsed, handler) {
+	if (parsed.extension === "xml" || parsed.extension === "json") return { role: "metadata" };
+	if (!parsed.suffix) return {
+		role: "source",
+		sourceComponent: "main"
+	};
+	if (parsed.type.toLowerCase() === "fugr" && parsed.suffix.toLowerCase() === `l${parsed.name.toLowerCase()}top`) return {
+		role: "source",
+		sourceComponent: "main"
+	};
+	return {
+		role: "source",
+		sourceComponent: handler.suffixToSourceKey?.[parsed.suffix] ?? parsed.suffix
+	};
+}
+function assertSupportsExplicitSources(handler, objectType, sources) {
+	if (!sources) return;
+	if (Object.keys(sources).length === 0) return;
+	if (handler.supportsExplicitSources) return;
+	throw new FormatMaterializationError("FORMAT_SOURCE_COMPONENT_UNSUPPORTED", `abapGit handler for "${objectType}" does not support explicit source selection.`);
+}
+async function buildMaterializedFiles(handler, object, packageDir, sources, format) {
+	return (await handler.serialize(object, {
+		...sources !== void 0 ? { sources } : {},
+		...format !== void 0 ? { format } : {}
+	})).map((file) => {
+		const parsed = parseAbapGitFilename(file.path);
+		const classification = parsed ? classifyFile(parsed, handler) : {
+			role: "source",
+			sourceComponent: "main"
+		};
+		const path = posix.join("src", packageDir, file.path);
+		return {
+			...file,
+			path,
+			...classification
+		};
+	}).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+}
 const abapgitFormatPlugin = {
 	id: "abapgit",
 	description: "abapGit serialization format",
@@ -4188,7 +7002,19 @@ const abapgitFormatPlugin = {
 		return getSupportedTypes();
 	},
 	getHandler(type) {
-		return getHandler(type);
+		const handler = getHandler(type);
+		return handler ? {
+			...handler,
+			supportsExplicitSources: handler.supportsExplicitSources ?? false
+		} : void 0;
+	},
+	async materialize(input) {
+		const handler = this.getHandler(input.objectType);
+		if (!handler) throw new FormatMaterializationError("FORMAT_OBJECT_TYPE_UNSUPPORTED", `abapGit does not support object type "${input.objectType}".`);
+		assertSupportsExplicitSources(handler, input.objectType, input.sources);
+		const folderLogic = parseFolderLogic(input.formatOptions?.folderLogic) ?? "prefix";
+		const packageDir = calculatePackageDir([...input.packagePath], folderLogic);
+		return { files: await buildMaterializedFiles(handler, input.object, packageDir, input.sources, input.formatOptions?.format) };
 	},
 	parseFilename(filename) {
 		return parseAbapGitFilename(filename) ?? void 0;
@@ -4217,6 +7043,9 @@ var AbapGitSerializer = class {
 		const writtenFiles = [];
 		for (const file of serializedFiles) {
 			const filePath = join(fullPackageDir, file.path);
+			const relativePath = relative(fullPackageDir, filePath);
+			if (!relativePath || isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep}`)) throw new Error(`Invalid serialized file path: ${file.path}`);
+			mkdirSync(dirname(filePath), { recursive: true });
 			writeFileSync(filePath, file.content, file.encoding ?? "utf8");
 			writtenFiles.push(filePath);
 		}
@@ -4291,7 +7120,8 @@ function readFolderLogicFromExistingRepo(targetPath) {
 	const abapgitXmlPath = join(targetPath, ".abapgit.xml");
 	if (!existsSync(abapgitXmlPath)) return;
 	try {
-		return parseFolderLogicFromAbapGitXml(readFileSync(abapgitXmlPath, "utf-8"));
+		const xmlContent = readFileSync(abapgitXmlPath, "utf-8");
+		return parseFolderLogicFromAbapGitXml(xmlContent);
 	} catch {
 		return;
 	}
@@ -4338,7 +7168,27 @@ const abapGitPlugin = createPlugin({
 				};
 			}
 		},
+		/**
+		* Export abapGit files to SAP
+		*
+		* Reads abapGit format files from FileTree and yields AdkObject instances.
+		* True generator - streams objects one at a time for memory efficiency.
+		*
+		* @param fileTree - Virtual file system abstraction
+		* @param client - ADT client for creating ADK objects
+		*/
 		export: (fileTree, client, options) => deserialize(fileTree, client, options),
+		/**
+		* Delete local abapGit files for an object marked for deletion in SAP.
+		*
+		* Searches the `<targetPath>/src/` directory tree for files matching
+		* the abapGit naming pattern `{name}.{type}[.suffix].{ext}` and removes
+		* each one.
+		*
+		* Known limitation: if the object never made it into the repository (e.g.
+		* PROG deletions without obj_func=D), no files are present and nothing
+		* happens. This is expected behavior.
+		*/
 		async delete(objectRef, targetPath, _context) {
 			try {
 				const matchedFiles = findObjectFiles(join(targetPath, "src"), objectRef.name, objectRef.type);
@@ -4370,145 +7220,12 @@ const abapGitPlugin = createPlugin({
 	},
 	hooks: { async afterImport(targetPath) {
 		mkdirSync(targetPath, { recursive: true });
-		writeFileSync(join(targetPath, ".abapgit.xml"), generateAbapGitXml(currentFolderLogic), "utf-8");
+		const abapgitXmlPath = join(targetPath, ".abapgit.xml");
+		const abapgitXmlContent = generateAbapGitXml(currentFolderLogic);
+		writeFileSync(abapgitXmlPath, abapgitXmlContent, "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);