@abapify/adt-plugin-gcts 0.4.1 → 0.4.3

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
 import { AdkClass, AdkDataElement, AdkDomain, AdkFunctionGroup, AdkInterface, AdkPackage, AdkProgram, AdkTable, AdkTableType, createAdk, getMainType, getTypeForKind } from "@abapify/adk";
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 //#region src/lib/format/filename.ts
 /**
@@ -15,8 +15,11 @@ const TYPE_TO_SOURCE_EXT = {
 	INTF: "abap",
 	PROG: "abap",
 	FUGR: "abap",
+	FUNC: "abap",
 	DDLS: "asddls",
-	DCLS: "asdcls"
+	DCLS: "asdcls",
+	BDEF: "abdl",
+	SRVD: "acds"
 };
 /** Metadata extension for all AFF/gCTS objects. */
 const METADATA_EXTENSION = "json";
@@ -59,11 +62,14 @@ function parseGctsFilename(filename) {
 		type: parts.at(-2).toUpperCase(),
 		extension
 	};
-	if (!new Set([
+	if (!(/* @__PURE__ */ new Set([
 		"abap",
 		"asddls",
-		"asdcls"
-	]).has(extension)) return;
+		"asdcls",
+		"abdl",
+		"acds",
+		"properties"
+	])).has(extension)) return;
 	if (parts.length >= 4) return {
 		name: parts.slice(0, -3).join("."),
 		type: parts.at(-3).toUpperCase(),
@@ -179,6 +185,17 @@ function createHandler(adkClassOrType, definition) {
 				path: metadataFile,
 				content: buildMetadataFile(metadata)
 			});
+			if (definition.getExtraFiles) {
+				const extras = await definition.getExtraFiles(object);
+				for (const extra of extras) {
+					const content = await resolveSource(extra);
+					if (!content) continue;
+					files.push({
+						path: extra.path,
+						content
+					});
+				}
+			}
 			return files;
 		},
 		fromAbapGit: definition.fromMetadata ? (values) => definition.fromMetadata(values) : void 0,
@@ -193,11 +210,15 @@ function createHandler(adkClassOrType, definition) {
 /**
 * CLAS handler for gCTS / AFF format.
 *
-* Projects ADK class data to the AFF class-metadata shape:
+* Projects ADK class data to the AFF clas-v1.json schema shape:
 *
 *   {
-*     header: { formatVersion, description, originalLanguage, ... },
-*     class: { category, visibility, final, abstract, ... }
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     category?,
+*     fixPointArithmetic?,
+*     messageClass?,
+*     descriptions?: { types?, attributes?, events?, methods? }
 *   }
 *
 * Sources are emitted per include (main, definitions, implementations, ...).
@@ -215,27 +236,39 @@ const SUFFIX = {
 	testclasses: "testclasses"
 };
 const SUFFIX_TO_SOURCE_KEY = Object.fromEntries(Object.entries(SUFFIX).filter(([, v]) => v !== void 0).map(([k, v]) => [v, k]));
+/**
+* ADK category enum → AFF category enum.
+* AFF uses a different, finer-grained set of category names.
+*/
+const CATEGORY_TO_AFF = {
+	generalObjectType: "generalObjectType",
+	exitClass: "exitClass",
+	testClass: "testclassAbapUnit",
+	behaviorPool: "behaviorClass",
+	entityEventHandler: "entityEventHandler",
+	persistentClass: "persistentClass",
+	factoryClass: "factoryForPersistentClass",
+	rfcProxyClass: "rfcProxyClass",
+	communicationConnectionClass: "communicationConnectionClass",
+	exceptionClass: "exceptionClass",
+	areaClass: "areaClassSharedObjects",
+	bspClass: "bspApplicationClass"
+};
+const CATEGORY_FROM_AFF = Object.fromEntries(Object.entries(CATEGORY_TO_AFF).map(([k, v]) => [v, k]));
 const classHandler = createHandler(AdkClass, {
 	suffixToSourceKey: SUFFIX_TO_SOURCE_KEY,
 	toMetadata(cls) {
 		const data = cls.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: cls.description ?? data.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage,
-				abapLanguageVersion: data.abapLanguageVersion
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
 			},
-			class: {
-				category: data.category,
-				visibility: data.visibility ?? "public",
-				final: data.final === true,
-				abstract: data.abstract === true,
-				fixedPointArithmetic: data.fixPointArithmetic === true,
-				unicodeChecksActive: data.activeUnicodeCheck !== false,
-				sharedMemoryEnabled: data.sharedMemoryEnabled === true,
-				superClass: data.superClassRef?.name
-			}
+			...data.category ? { category: CATEGORY_TO_AFF[data.category] ?? "generalObjectType" } : {},
+			...typeof data.fixPointArithmetic === "boolean" ? { fixPointArithmetic: data.fixPointArithmetic } : {}
 		};
 	},
 	getSources: (cls) => {
@@ -245,16 +278,14 @@ const classHandler = createHandler(AdkClass, {
 		}));
 	},
 	fromMetadata: (meta) => ({
-		name: (meta?.class?.name ?? "").toUpperCase(),
+		name: "",
 		type: "CLAS/OC",
-		description: meta?.header?.description,
-		language: meta?.header?.originalLanguage,
-		masterLanguage: meta?.header?.originalLanguage,
-		category: meta?.class?.category,
-		visibility: meta?.class?.visibility,
-		final: meta?.class?.final === true,
-		abstract: meta?.class?.abstract === true,
-		abapLanguageVersion: meta?.header?.abapLanguageVersion
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		category: meta.category ? CATEGORY_FROM_AFF[meta.category] ?? meta.category : void 0,
+		abapLanguageVersion: meta.header.abapLanguageVersion,
+		fixPointArithmetic: meta.fixPointArithmetic
 	}),
 	setSources: (cls, sources) => {
 		cls._pendingSources = sources;
@@ -266,28 +297,38 @@ const classHandler = createHandler(AdkClass, {
 //#region src/lib/handlers/objects/intf.ts
 /**
 * INTF handler for gCTS / AFF format.
+*
+* Projects ADK interface data to the AFF intf-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     category?,
+*     proxy?,
+*     descriptions?
+*   }
 */
 const interfaceHandler = createHandler(AdkInterface, {
 	toMetadata(intf) {
 		const data = intf.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: intf.description ?? data.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage,
-				abapLanguageVersion: data.abapLanguageVersion
-			},
-			interface: { unicodeChecksActive: data.activeUnicodeCheck !== false }
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
+			}
 		};
 	},
 	getSource: (obj) => obj.getSource(),
 	fromMetadata: (meta) => ({
-		name: (meta?.interface?.name ?? "").toUpperCase(),
+		name: "",
 		type: "INTF/OI",
-		description: meta?.header?.description,
-		language: meta?.header?.originalLanguage,
-		masterLanguage: meta?.header?.originalLanguage,
-		abapLanguageVersion: meta?.header?.abapLanguageVersion
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		abapLanguageVersion: meta.header.abapLanguageVersion
 	}),
 	setSources: (intf, sources) => {
 		if (sources.main) intf._pendingSource = sources.main;
@@ -298,31 +339,53 @@ const interfaceHandler = createHandler(AdkInterface, {
 //#region src/lib/handlers/objects/prog.ts
 /**
 * PROG handler for gCTS / AFF format.
+*
+* Projects ADK program data to the AFF prog-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     generalInformation: { programType, programStatus, fixPointArithmetic?, ... }
+*   }
 */
+/** ADK sourceObjectStatus → AFF programStatus */
+const STATUS_TO_AFF = {
+	SAPStandardProduction: "sapProductionProgram",
+	customerProduction: "customerProductionProgram",
+	system: "systemProgram",
+	test: "testProgram"
+};
+const STATUS_FROM_AFF = Object.fromEntries(Object.entries(STATUS_TO_AFF).map(([k, v]) => [v, k]));
 const programHandler = createHandler(AdkProgram, {
 	toMetadata(prog) {
 		const data = prog.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const generalInformation = {
+			programType: data.programType ?? "executableProgram",
+			programStatus: STATUS_TO_AFF[data.sourceObjectStatus ?? ""] ?? "systemProgram"
+		};
+		if (typeof data.fixPointArithmetic === "boolean") generalInformation.fixPointArithmetic = data.fixPointArithmetic;
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: prog.description ?? data.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage,
-				abapLanguageVersion: data.abapLanguageVersion
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
 			},
-			program: {
-				programType: data.programType ?? "executableProgram",
-				fixedPointArithmetic: data.fixPointArithmetic === true,
-				unicodeChecksActive: data.activeUnicodeCheck !== false
-			}
+			generalInformation
 		};
 	},
 	getSource: (obj) => obj.getSource(),
 	fromMetadata: (meta) => ({
-		name: (meta?.program?.name ?? "").toUpperCase(),
+		name: "",
 		type: "PROG/P",
-		description: meta?.header?.description,
-		language: meta?.header?.originalLanguage,
-		programType: meta?.program?.programType
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		programType: meta.generalInformation?.programType,
+		sourceObjectStatus: meta.generalInformation?.programStatus ? STATUS_FROM_AFF[meta.generalInformation.programStatus] : void 0,
+		fixPointArithmetic: meta.generalInformation?.fixPointArithmetic,
+		abapLanguageVersion: meta.header.abapLanguageVersion
 	}),
 	setSources: (prog, sources) => {
 		if (sources.main) prog._pendingSource = sources.main;
@@ -336,15 +399,20 @@ const programHandler = createHandler(AdkProgram, {
 *
 * Packages use a fixed filename (`package.devc.json`) — same convention as
 * abapGit's `package.devc.xml`.
+*
+* Note: DEVC has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a DEVC
+* schema later, align here.
 */
 const packageHandler = createHandler(AdkPackage, {
 	metadataFileName: PACKAGE_FILENAME,
 	toMetadata(pkg) {
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: pkg.description ?? "",
-				originalLanguage: pkg.dataSync?.language ?? pkg.dataSync?.masterLanguage
+				originalLanguage: (pkg.dataSync?.language ?? pkg.dataSync?.masterLanguage ?? "").toLowerCase(),
+				...pkg.dataSync?.abapLanguageVersion && pkg.dataSync.abapLanguageVersion !== "standard" ? { abapLanguageVersion: pkg.dataSync.abapLanguageVersion } : {}
 			},
 			package: {
 				softwareComponent: pkg.dataSync?.transport?.softwareComponent?.name,
@@ -355,7 +423,10 @@ const packageHandler = createHandler(AdkPackage, {
 	},
 	fromMetadata: (meta) => ({
 		name: "",
-		description: meta?.header?.description
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase(),
+		masterLanguage: meta?.header?.originalLanguage?.toUpperCase(),
+		abapLanguageVersion: meta?.header?.abapLanguageVersion
 	})
 });
 
@@ -363,79 +434,188 @@ const packageHandler = createHandler(AdkPackage, {
 //#region src/lib/handlers/objects/doma.ts
 /**
 * DOMA (domain) handler for gCTS / AFF format.
+*
+* Projects ADK domain data to the AFF doma-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     format: { dataType, length, decimals? } (required),
+*     outputCharacteristics?: { length?, caseSensitive?, conversionRoutine?, ... },
+*     valueTable?: { name }
+*   }
 */
 const domainHandler = createHandler(AdkDomain, {
 	toMetadata(doma) {
 		const data = doma.dataSync;
-		return {
+		const content = data.content ?? {};
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const ti = content.typeInformation ?? {};
+		const oi = content.outputInformation ?? {};
+		const vi = content.valueInformation ?? {};
+		const format = {
+			dataType: ti.datatype ?? "CHAR",
+			length: ti.length ?? 1
+		};
+		if (typeof ti.decimals === "number") format.decimals = ti.decimals;
+		const result = {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: doma.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage
+				originalLanguage: lang
 			},
-			domain: {
-				dataType: data.dataType,
-				length: data.length,
-				decimals: data.decimals,
-				outputLength: data.outputLength,
-				caseSensitive: data.caseSensitive === true,
-				valueTable: data.valueTableRef?.name
-			}
+			format
 		};
+		const outChars = {};
+		if (typeof oi.length === "number") outChars.length = oi.length;
+		if (typeof oi.lowercase === "boolean") outChars.caseSensitive = !oi.lowercase;
+		if (oi.conversionExit) outChars.conversionRoutine = oi.conversionExit;
+		if (Object.keys(outChars).length > 0) result.outputCharacteristics = outChars;
+		const vtRef = vi.valueTableRef ?? {};
+		if (vtRef.name) result.valueTable = { name: vtRef.name };
+		return result;
 	},
-	fromMetadata: (meta) => ({
-		name: (meta?.domain?.name ?? "").toUpperCase(),
-		description: meta?.header?.description,
-		dataType: meta?.domain?.dataType,
-		length: meta?.domain?.length,
-		decimals: meta?.domain?.decimals
-	})
+	fromMetadata: (meta) => {
+		const result = {
+			name: "",
+			description: meta.header.description,
+			language: meta.header.originalLanguage?.toUpperCase(),
+			masterLanguage: meta.header.originalLanguage?.toUpperCase()
+		};
+		const content = { typeInformation: {
+			datatype: meta.format.dataType,
+			length: meta.format.length,
+			decimals: meta.format.decimals ?? 0
+		} };
+		if (meta.outputCharacteristics) content.outputInformation = {
+			length: meta.outputCharacteristics.length,
+			lowercase: meta.outputCharacteristics.caseSensitive ? false : void 0,
+			conversionExit: meta.outputCharacteristics.conversionRoutine
+		};
+		if (meta.valueTable?.name) content.valueInformation = { valueTableRef: { name: meta.valueTable.name } };
+		result.content = content;
+		return result;
+	}
 });
 
 //#endregion
 //#region src/lib/handlers/objects/dtel.ts
 /**
 * DTEL (data element) handler for gCTS / AFF format.
+*
+* Projects ADK data element data to the AFF dtel-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     dataTypeInformation: { domainName? } | { predefinedType: { dataType, length?, decimals? } },
+*     fieldLabels?: { short, shortLength, medium, mediumLength, long, longLength, heading, headingLength }
+*   }
 */
+function buildDataTypeInformation(data) {
+	if (data.typeKind === "domain" && data.typeName) return { domainName: data.typeName };
+	if (data.dataType) {
+		const predefinedType = { dataType: data.dataType };
+		if (typeof data.dataTypeLength === "number") predefinedType.length = data.dataTypeLength;
+		if (typeof data.dataTypeDecimals === "number") predefinedType.decimals = data.dataTypeDecimals;
+		return { predefinedType };
+	}
+	return {};
+}
+function buildFieldLabels(data) {
+	const labels = {};
+	for (const [src, dst, lenKey] of [
+		[
+			"shortFieldLabel",
+			"short",
+			"shortFieldLength"
+		],
+		[
+			"mediumFieldLabel",
+			"medium",
+			"mediumFieldLength"
+		],
+		[
+			"longFieldLabel",
+			"long",
+			"longFieldLength"
+		],
+		[
+			"headingFieldLabel",
+			"heading",
+			"headingFieldLength"
+		]
+	]) if (data[src]) {
+		labels[dst] = data[src];
+		if (typeof data[lenKey] === "number") labels[`${dst}Length`] = data[lenKey];
+	}
+	return labels;
+}
 const dataElementHandler = createHandler(AdkDataElement, {
 	toMetadata(dtel) {
 		const data = dtel.dataSync;
-		return {
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const result = {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: dtel.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage
+				originalLanguage: lang
 			},
-			dataElement: {
-				typeKind: data.typeKind,
-				dataType: data.dataType,
-				length: data.length,
-				decimals: data.decimals,
-				domain: data.domainRef?.name,
-				predefinedType: data.predefinedType
-			}
+			dataTypeInformation: buildDataTypeInformation(data)
 		};
+		const fieldLabels = buildFieldLabels(data);
+		if (Object.keys(fieldLabels).length > 0) result.fieldLabels = fieldLabels;
+		return result;
 	},
-	fromMetadata: (meta) => ({
-		name: (meta?.dataElement?.name ?? "").toUpperCase(),
-		description: meta?.header?.description,
-		dataType: meta?.dataElement?.dataType
-	})
+	fromMetadata: (meta) => {
+		const dti = meta.dataTypeInformation ?? {};
+		const result = {
+			name: "",
+			description: meta.header.description,
+			language: meta.header.originalLanguage?.toUpperCase(),
+			masterLanguage: meta.header.originalLanguage?.toUpperCase()
+		};
+		if (dti.domainName) {
+			result.typeKind = "domain";
+			result.typeName = dti.domainName;
+		} else if (dti.predefinedType) {
+			result.typeKind = "predefinedAbapType";
+			result.dataType = dti.predefinedType.dataType;
+			result.dataTypeLength = dti.predefinedType.length;
+			result.dataTypeDecimals = dti.predefinedType.decimals;
+		}
+		const fl = meta.fieldLabels;
+		if (fl) {
+			result.shortFieldLabel = fl.short;
+			result.shortFieldLength = fl.shortLength;
+			result.mediumFieldLabel = fl.medium;
+			result.mediumFieldLength = fl.mediumLength;
+			result.longFieldLabel = fl.long;
+			result.longFieldLength = fl.longLength;
+			result.headingFieldLabel = fl.heading;
+			result.headingFieldLength = fl.headingLength;
+		}
+		return result;
+	}
 });
 
 //#endregion
 //#region src/lib/handlers/objects/tabl.ts
 /**
 * TABL (table / structure) handler for gCTS / AFF format.
+*
+* Note: TABL has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a TABL
+* schema later, align here.
 */
 const tableHandler = createHandler(AdkTable, {
 	toMetadata(tabl) {
 		const data = tabl.dataSync;
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: tabl.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage
+				originalLanguage: (data.language ?? data.masterLanguage ?? "").toLowerCase()
 			},
 			table: {
 				tableCategory: data.tableCategory,
@@ -446,8 +626,14 @@ const tableHandler = createHandler(AdkTable, {
 		};
 	},
 	fromMetadata: (meta) => ({
-		name: (meta?.table?.name ?? "").toUpperCase(),
-		description: meta?.header?.description
+		name: "",
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase(),
+		masterLanguage: meta?.header?.originalLanguage?.toUpperCase(),
+		tableCategory: meta?.table?.tableCategory,
+		deliveryClass: meta?.table?.deliveryClass,
+		dataMaintenance: meta?.table?.dataMaintenance,
+		fields: meta?.table?.fields
 	})
 });
 
@@ -455,15 +641,19 @@ const tableHandler = createHandler(AdkTable, {
 //#region src/lib/handlers/objects/ttyp.ts
 /**
 * TTYP (table type) handler for gCTS / AFF format.
+*
+* Note: TTYP has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a TTYP
+* schema later, align here.
 */
 const tableTypeHandler = createHandler(AdkTableType, {
 	toMetadata(ttyp) {
 		const data = ttyp.dataSync;
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: ttyp.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage
+				originalLanguage: (data.language ?? data.masterLanguage ?? "").toLowerCase()
 			},
 			tableType: {
 				accessMode: data.accessMode,
@@ -474,8 +664,9 @@ const tableTypeHandler = createHandler(AdkTableType, {
 		};
 	},
 	fromMetadata: (meta) => ({
-		name: (meta?.tableType?.name ?? "").toUpperCase(),
-		description: meta?.header?.description
+		name: "",
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase()
 	})
 });
 
@@ -484,31 +675,418 @@ const tableTypeHandler = createHandler(AdkTableType, {
 /**
 * FUGR (function group) handler for gCTS / AFF format.
 *
+* Projects ADK function group data to the AFF fugr-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     fixPointArithmetic: boolean (required),
+*     status?
+*   }
+*
 * AFF's FUGR representation nests function modules under the group
-* directory. This plugin emits the group metadata only — per-module files
-* are produced by individual FUNC handlers once ADK exposes them.
+* directory. This handler emits the group metadata plus per-function-module
+* files when function module data is available:
+*   <fmname>.func.json — FM metadata (func-v1.json schema)
+*   <fmname>.func.abap — FM source
 */
+function buildFuncMetadata(fm) {
+	const meta = {
+		formatVersion: "1",
+		header: { description: fm.description ?? fm.name ?? "" },
+		processingType: fm.processingType ?? "normal",
+		includeNumber: fm.includeNumber ?? "0000"
+	};
+	return JSON.stringify(meta, null, 2) + "\n";
+}
 const functionGroupHandler = createHandler(AdkFunctionGroup, {
 	toMetadata(fugr) {
-		const data = fugr.dataSync;
+		const data = fugr.dataSync ?? {};
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
 		return {
+			formatVersion: "1",
 			header: {
-				formatVersion: "1.0",
 				description: fugr.description ?? "",
-				originalLanguage: data.language ?? data.masterLanguage
+				originalLanguage: lang
+			},
+			fixPointArithmetic: data.fixPointArithmetic === true
+		};
+	},
+	getSource: (fugr) => typeof fugr.getSource === "function" ? fugr.getSource() : "",
+	getExtraFiles(fugr) {
+		const fms = fugr.functionModules ?? [];
+		const files = [];
+		for (const fm of fms) {
+			const fmName = fm.name.toLowerCase();
+			files.push({
+				path: `${fmName}.func.json`,
+				content: buildFuncMetadata(fm)
+			});
+			if (fm.source) files.push({
+				path: `${fmName}.func.abap`,
+				content: fm.source
+			});
+		}
+		return files;
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		fixPointArithmetic: meta.fixPointArithmetic
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/ddls.ts
+/**
+* DDLS (CDS view) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.ddls.asddls` (source) + `<name>.ddls.json`
+* (metadata per ddls-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     sourceOrigin: "abapDevelopmentTools" (required),
+*     sourceType: "unknown" (required),
+*     parentName?: string
+*   }
+*/
+const ddlSourceHandler = createHandler("DDLS", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			},
+			sourceOrigin: obj.sourceOrigin ?? "abapDevelopmentTools",
+			sourceType: obj.sourceType ?? "unknown"
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		sourceOrigin: meta.sourceOrigin,
+		sourceType: meta.sourceType
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/dcls.ts
+/**
+* DCLS (CDS access control) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.dcls.asdcls` (source) + `<name>.dcls.json`
+* (metadata per dcls-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? }
+*   }
+*/
+const dclSourceHandler = createHandler("DCLS", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			}
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/bdef.ts
+/**
+* BDEF (RAP behavior definition) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.bdef.abdl` (source) + `<name>.bdef.json`
+* (metadata per bdef-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     extendedBehaviorDefintion?: { name?: string }
+*   }
+*/
+const behaviorDefinitionHandler = createHandler("BDEF", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			}
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/srvd.ts
+/**
+* SRVD (RAP service definition) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.srvd.acds` (source) + `<name>.srvd.json`
+* (metadata per srvd-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     generalInformation: { sourceOrigin, sourceType }
+*   }
+*/
+const serviceDefinitionHandler = createHandler("SRVD", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
 			},
-			functionGroup: {
-				fixedPointArithmetic: data.fixPointArithmetic === true,
-				unicodeChecksActive: data.activeUnicodeCheck !== false
+			generalInformation: {
+				sourceOrigin: obj.sourceOrigin ?? "abapDevelopmentTools",
+				sourceType: obj.sourceType ?? "definition"
 			}
 		};
 	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
 	fromMetadata: (meta) => ({
-		name: (meta?.functionGroup?.name ?? "").toUpperCase(),
-		description: meta?.header?.description
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		sourceOrigin: meta.generalInformation.sourceOrigin,
+		sourceType: meta.generalInformation.sourceType
 	})
 });
 
+//#endregion
+//#region src/lib/handlers/objects/srvb.ts
+/**
+* SRVB (RAP service binding) handler for gCTS / AFF format.
+*
+* Metadata-only (no source): emits `<name>.srvb.json` only
+* (metadata per srvb-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     bindingType: string (required),
+*     bindingTypeCategory: "ui" | "webApi" (required),
+*     services: [{ name, versions: [{ serviceVersion, serviceDefinition }] }]
+*   }
+*/
+const serviceBindingHandler = createHandler("SRVB", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			},
+			bindingType: obj.bindingType ?? "",
+			bindingTypeCategory: obj.bindingTypeCategory ?? "ui",
+			services: obj.services ?? []
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		bindingType: meta.bindingType,
+		bindingTypeCategory: meta.bindingTypeCategory,
+		services: meta.services
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/msag.ts
+/**
+* MSAG (message class) handler for gCTS / AFF format.
+*
+* Metadata-only (no source): emits `<name>.msag.json` only
+* (metadata per msag-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage },
+*     messages: [{ number?: string, text?: string }]
+*   }
+*/
+const messageClassHandler = createHandler("MSAG", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang
+			},
+			messages: obj.messages ?? []
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		messages: meta.messages
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/wave2-generic.ts
+/**
+* Generic AFF handler stubs for the remaining object types.
+*
+* Wave 2 mass-generates handlers for all AFF types that have JSON schemas
+* but no dedicated handler. Each stub emits the minimal AFF contract:
+*   { formatVersion: "1", header: { description, originalLanguage } }
+*
+* Type-specific fields can be added later by promoting a stub to a
+* dedicated handler file (like clas.ts, ddls.ts, etc.) when the ADK
+* object model exposes richer data for that type.
+*
+* All types here are registered via the string-type form of
+* `createHandler` — no ADK class required.
+*/
+function toMetadata(obj) {
+	const lang = (obj.originalLanguage ?? "").toLowerCase();
+	const meta = {
+		formatVersion: "1",
+		header: {
+			description: obj.description ?? obj.name ?? "",
+			originalLanguage: lang
+		}
+	};
+	if (obj.abapLanguageVersion) meta.header.abapLanguageVersion = obj.abapLanguageVersion;
+	return meta;
+}
+function fromMetadata(meta) {
+	return {
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	};
+}
+function getSource(obj) {
+	return typeof obj.getSource === "function" ? obj.getSource() : "";
+}
+for (const type of [
+	"ADVC",
+	"AIFA",
+	"AIFD",
+	"AIFF",
+	"AIFI",
+	"AIFN",
+	"AIFP",
+	"AIFR",
+	"AOBJ",
+	"APIC",
+	"APLO",
+	"APOB",
+	"BGQC",
+	"CDBO",
+	"CFDF",
+	"CHDO",
+	"CHKC",
+	"CHKO",
+	"CHKV",
+	"COTA",
+	"CSNM",
+	"DCAT",
+	"DDLA",
+	"DDLX",
+	"DESD",
+	"DMON",
+	"DOBJ",
+	"DRAS",
+	"DRTY",
+	"DSFD",
+	"DSFI",
+	"DTDC",
+	"DTEB",
+	"DTIX",
+	"DTSC",
+	"EDCC",
+	"EDCK",
+	"EDCR",
+	"EDOI",
+	"EEEC",
+	"ENHO",
+	"ENHS",
+	"ENQU",
+	"EVTB",
+	"EVTO",
+	"GSMP",
+	"HTTP",
+	"ILMB",
+	"INTM",
+	"INTS",
+	"IWNG",
+	"NONT",
+	"NROB",
+	"NTTA",
+	"NTTY",
+	"RONT",
+	"RVBC",
+	"SAIA",
+	"SAJC",
+	"SAJT",
+	"SCP1",
+	"SFPF",
+	"SIAD",
+	"SITO",
+	"SMBC",
+	"SMTG",
+	"SPRV",
+	"SRVC",
+	"SUCO",
+	"SUSI",
+	"SWCR",
+	"SXTG",
+	"UIAD",
+	"UIPG",
+	"UIST"
+]) createHandler(type, {
+	toMetadata,
+	getSource,
+	fromMetadata
+});
+
 //#endregion
 //#region src/lib/format/gcts-format.ts
 const gctsFormatPlugin = {
@@ -528,7 +1106,7 @@ const gctsFormatPlugin = {
 //#endregion
 //#region src/lib/deserializer.ts
 /** Source-file extensions emitted by gCTS handlers. */
-const SOURCE_EXTENSIONS = new Set([
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 	"abap",
 	"asddls",
 	"asdcls"
@@ -579,7 +1157,8 @@ async function* deserialize(fileTree, client, options) {
 	for (const ext of SOURCE_EXTENSIONS) {
 		const paths = await fileTree.glob(`**/*.${ext}`);
 		for (const path of paths) {
-			const parsed = parseGctsFilename(path.split("/").pop());
+			const filename = path.split("/").pop();
+			const parsed = parseGctsFilename(filename);
 			if (!parsed) continue;
 			const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
 			const obj = objectMap.get(key);
@@ -702,6 +1281,10 @@ const gctsPlugin = createPlugin({
 * throughout the `adt` CLI.
 */
 registerFormatPlugin(gctsFormatPlugin);
+registerFormatPlugin({
+	...gctsFormatPlugin,
+	id: "aff"
+});
 
 //#endregion
 export { gctsPlugin as GctsPlugin, gctsPlugin as default, gctsPlugin, METADATA_EXTENSION, PACKAGE_FILENAME, adtUriToGctsPath, createHandler, gctsFilename, gctsFormatPlugin, getHandler, getSupportedTypes, isSupported, parseGctsFilename };