@abapify/adt-plugin-gcts 0.4.21 → 0.4.25

package/dist/index.mjs

@@ -1,7 +1,10 @@
+import { t as __exportAll } from "./rolldown-runtime-CNh9ExCG.mjs";
 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 "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
 
 // src/lib/format/filename.ts
 /**
@@ -19,26 +22,123 @@ const TYPE_TO_SOURCE_EXT = {
 	DDLS: "asddls",
 	DCLS: "asdcls",
 	BDEF: "abdl",
-	SRVD: "acds"
+	SRVD: "acds",
+	DDLA: "acds",
+	DDLX: "acds",
+	DTSC: "acds",
+	DTIX: "acds",
+	DTEB: "acds",
+	DTDC: "acds",
+	DRAS: "acds",
+	DRTY: "acds",
+	DSFD: "acds",
+	CSNM: "csn",
+	SFPF: "xdp",
+	XSLT: "xml"
 };
 /** Metadata extension for all AFF/gCTS objects. */
 const METADATA_EXTENSION = "json";
 /** Fixed filename for package metadata (AFF / gCTS convention). */
 const PACKAGE_FILENAME = "package.devc.json";
 /**
+* AFF filename-safe form of an object name: namespaces encode as brackets
+* (`/NMSPC/CL_OBJECT` → `(nmspc)cl_object`, AFF spec §file-names) so a
+* `/` in the name can never split the file into nested directories.
+*/
+function affName(name) {
+	return name.toLowerCase().replace(/^\/([^/]+)\//, "($1)");
+}
+/**
 * Build the AFF/gCTS on-disk filename for an object.
 *
 * @param name     Object name (case preserved — AFF normalises to lowercase)
 * @param type     ABAP object type code (CLAS, INTF, ...)
 * @param kind     `"metadata"` (default) or `"source"`.
-* @param suffix   Optional sub-include suffix (e.g. `locals_def` for CLAS).
+* @param suffix   Optional sub-include suffix (e.g. `locals_def` for CLAS,
+*                  or `z_func.func` for a LIMU sub-object).
+* @param ext      Source-file extension override — defaults to the type's
+*                  extension (`abap`, `acds`, …). Needed for companions whose
+*                  extension differs from the type's main source (`.json`
+*                  LIMU metadata, `.properties` texts).
 */
-function gctsFilename(name, type, kind = "metadata", suffix) {
-	const base = name.toLowerCase();
+function gctsFilename(name, type, kind = "metadata", suffix, ext) {
+	const base = affName(name);
 	const typeLower = mainType(type).toLowerCase();
 	if (kind === "metadata") return `${base}.${typeLower}.${METADATA_EXTENSION}`;
-	const ext = TYPE_TO_SOURCE_EXT[mainType(type).toUpperCase()] ?? "abap";
-	return suffix ? `${base}.${typeLower}.${suffix}.${ext}` : `${base}.${typeLower}.${ext}`;
+	const sourceExt = ext ?? TYPE_TO_SOURCE_EXT[mainType(type).toUpperCase()] ?? "abap";
+	return suffix ? `${base}.${typeLower}.${suffix}.${sourceExt}` : `${base}.${typeLower}.${sourceExt}`;
+}
+/**
+* LIMU sub-object type codes (AFF spec §file-names): they never appear as
+* root objects — a `{parent}.{ptype}.{sub}.{stype}.{ext}` filename routes to
+* the parent object with `{sub}.{stype}` as its suffix.
+*/
+const LIMU_SUBTYPES = /* @__PURE__ */ new Set([
+	"func",
+	"reps",
+	"cpub",
+	"cpro",
+	"cprt",
+	"cpri",
+	"sotr",
+	"sotu"
+]);
+/**
+* The default source-file extension for an object type (`abap` fallback) —
+* used to decide whether a source-key suffix carries an explicit extension.
+*/
+function gctsSourceExt(type) {
+	return TYPE_TO_SOURCE_EXT[mainType(type).toUpperCase()] ?? "abap";
+}
+/** Source/companion extensions recognised by the spec file-name grammar. */
+const KNOWN_SOURCE_EXTS = /* @__PURE__ */ new Set([
+	"abap",
+	"asddls",
+	"asdcls",
+	"abdl",
+	"acds",
+	"csn",
+	"xdp",
+	"ddic",
+	"properties",
+	"xml"
+]);
+/** Every file extension the spec grammar can carry after the suffix. */
+const KNOWN_FILE_EXTS = /* @__PURE__ */ new Set([...KNOWN_SOURCE_EXTS, METADATA_EXTENSION]);
+/**
+* Encode a companion file as a source-map key: bare `suffix` when the file
+* uses the type's default source extension, `{suffix}.{ext}` when it does
+* not (e.g. `z_func.func.json` → LIMU metadata, `texts.en.properties` →
+* translated texts). Symmetric with `splitSourceKey`.
+*/
+function sourceKey(type, suffix, ext) {
+	return !ext || ext === gctsSourceExt(type) ? suffix : `${suffix}.${ext}`;
+}
+/**
+* Inverse of `sourceKey`: splits a source-map key into the filename suffix
+* and an optional extension override (`undefined` → the type's default).
+*/
+function splitSourceKey(key) {
+	if (key === "main") return {
+		suffix: void 0,
+		ext: void 0
+	};
+	if (key.startsWith("main.")) {
+		const tail = key.slice(5);
+		if (KNOWN_FILE_EXTS.has(tail)) return {
+			suffix: void 0,
+			ext: tail
+		};
+	}
+	const dot = key.lastIndexOf(".");
+	if (dot > 0 && KNOWN_FILE_EXTS.has(key.slice(dot + 1))) return {
+		suffix: key.slice(0, dot),
+		ext: key.slice(dot + 1)
+	};
+	return {
+		suffix: key,
+		ext: void 0
+	};
 }
 /**
 * Parse an AFF/gCTS filename back into its components.
@@ -53,23 +153,71 @@ function parseGctsFilename(filename) {
 		extension: METADATA_EXTENSION
 	};
 	const parts = filename.split(".");
-	if (parts.length < 3) return;
+	if (parts.length < 3) return void 0;
 	const extension = parts.at(-1);
-	const nameParts = (parts.length >= 4 ? parts.at(-2) : void 0) ? parts.slice(0, -3) : parts.slice(0, -2);
-	if (nameParts.length === 0) return;
-	if (extension === "json") return {
-		name: nameParts.length === 0 ? "" : parts.slice(0, -2).join("."),
+	if (extension === "json") return parseMetadataName(parts);
+	if (extension === "properties") return parsePropertiesName(parts);
+	return parseSourceName(parts, extension);
+}
+/**
+* `{name}.{type}.json`, plus the DOCU companion form
+* `{name}.{type}.docu.json` which belongs to the parent object.
+*/
+function parseMetadataName(parts) {
+	const docu = parts.at(-2) === "docu" && parts.length >= 4;
+	const limu = parts.length >= 5 && LIMU_SUBTYPES.has(parts.at(-2));
+	let offset = -2;
+	if (docu) offset = -3;
+	else if (limu) offset = -4;
+	const parsed = {
+		name: parts.slice(0, offset).join("."),
+		type: parts.at(offset).toUpperCase(),
+		extension: METADATA_EXTENSION
+	};
+	if (docu) parsed.suffix = "docu";
+	else if (limu) parsed.suffix = `${parts.at(-3)}.${parts.at(-2)}`;
+	return parsed;
+}
+/**
+* `.properties` text files have their own grammar:
+*   {name}.{type}.properties                        — master (3 parts)
+*   {name}.{type}.{lang}.properties                 — language (4 parts)
+*   {name}.{type}.{content_type}.{lang}.properties  — e.g. PROG
+*   selections/headings/texts (5 parts)
+* The composite suffix (`de`, `texts.en`) stays opaque — handlers map
+* suffixes to source keys via `suffixToSourceKey`.
+*/
+function parsePropertiesName(parts) {
+	if (parts.length >= 5) return {
+		name: parts.slice(0, -4).join("."),
+		type: parts.at(-4).toUpperCase(),
+		suffix: `${parts.at(-3)}.${parts.at(-2)}`,
+		extension: "properties"
+	};
+	if (parts.length === 4) return {
+		name: parts.slice(0, -3).join("."),
+		type: parts.at(-3).toUpperCase(),
+		suffix: parts.at(-2),
+		extension: "properties"
+	};
+	return {
+		name: parts.slice(0, -2).join("."),
 		type: parts.at(-2).toUpperCase(),
+		extension: "properties"
+	};
+}
+/**
+* `{name}.{type}.{ext}` and `{name}.{type}.{suffix}.{ext}` source files —
+* a suffix is present iff there are ≥4 dot-segments.
+*/
+function parseSourceName(parts, extension) {
+	if (!KNOWN_SOURCE_EXTS.has(extension)) return void 0;
+	if (parts.length >= 5 && LIMU_SUBTYPES.has(parts.at(-2))) return {
+		name: parts.slice(0, -4).join("."),
+		type: parts.at(-4).toUpperCase(),
+		suffix: `${parts.at(-3)}.${parts.at(-2)}`,
 		extension
 	};
-	if (!(/* @__PURE__ */ new Set([
-		"abap",
-		"asddls",
-		"asdcls",
-		"abdl",
-		"acds",
-		"properties"
-	])).has(extension)) return;
 	if (parts.length >= 4) return {
 		name: parts.slice(0, -3).join("."),
 		type: parts.at(-3).toUpperCase(),
@@ -118,6 +266,392 @@ function mainType(type) {
 	return type.split("/")[0];
 }
 
+// src/lib/aff/schemas.ts
+/**
+* AFF schema access over the `git_modules/abap-file-formats` submodule.
+*
+* The submodule pin (`.gitmodules`) is the provenance record — schemas and
+* examples are always read from it at the pinned upstream SHA. This module
+* has no workspace dependencies (ajv + node builtins only) so schema
+* conformance tests run without building the workspace.
+*/
+const SCHEMA_RE = /^([a-z0-9]+)-v(\d+)\.json$/;
+/**
+* Locate the AFF schema root. Published packages ship only `dist`, so the
+* bundled `aff-schemas/` copy (produced by the build) is tried first; the
+* `git_modules` submodule is the dev fallback. Returns `undefined` when
+* neither exists — callers degrade gracefully instead of breaking plugin
+* load on installs that lack the submodule.
+*/
+function findAffRoot() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 10; i++) {
+		const bundled = join(dir, "aff-schemas");
+		if (existsSync(bundled)) return bundled;
+		const submodule = join(dir, "git_modules/abap-file-formats/file-formats");
+		if (existsSync(submodule)) return submodule;
+		dir = dirname(dir);
+	}
+}
+let rootCache;
+/** Resolved AFF schema root, or `undefined` when unavailable. */
+function affRoot() {
+	if (rootCache === void 0) rootCache = findAffRoot() ?? null;
+	return rootCache ?? void 0;
+}
+/** All official AFF object types (directories in `file-formats/`). */
+function listAffTypes() {
+	const root = affRoot();
+	return root ? readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b) => a.localeCompare(b)) : [];
+}
+/** Format versions available for a type, newest first. */
+function affVersions(ref) {
+	const type = ref.type.toLowerCase();
+	const root = affRoot();
+	if (!root) return [];
+	const dir = join(root, type);
+	const scoped = existsSync(dir) ? readdirSync(dir) : [];
+	const loose = readdirSync(root);
+	const nested = readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== type).flatMap((e) => {
+		try {
+			return readdirSync(join(root, e.name));
+		} catch {
+			return [];
+		}
+	});
+	return [...new Set([
+		...scoped,
+		...loose,
+		...nested
+	].map((f) => SCHEMA_RE.exec(f)).filter((m) => !!m && m[1] === type).map((m) => Number(m[2])))].sort((a, b) => b - a);
+}
+function latestAffVersion(ref) {
+	return affVersions(ref)[0];
+}
+/** `<root>/<type>/<type>-vN.json` or root-level `<type>-vN.json` (docu). */
+function directSchemaFile(q) {
+	const stem = `${q.type}-v${q.version}.json`;
+	for (const file of [join(q.root, q.type, stem), join(q.root, stem)]) if (existsSync(file)) return file;
+}
+/** LIMU sub-object schemas nest under their parent's dir (`fugr/func-v1.json`). */
+function nestedSchemaFile(q) {
+	for (const dir of listAffTypes()) {
+		if (dir === q.type) continue;
+		const file = join(q.root, dir, `${q.type}-v${q.version}.json`);
+		if (existsSync(file)) return file;
+	}
+}
+/** First existing candidate path for a type+version schema, or none. */
+function findSchemaFile(q) {
+	return directSchemaFile(q) ?? nestedSchemaFile(q);
+}
+function affSchema(ref) {
+	const type = ref.type.toLowerCase();
+	const version = ref.version ?? latestAffVersion({
+		...ref,
+		type
+	});
+	if (!version) throw new Error(`No AFF schema for ${type}`);
+	const root = affRoot();
+	if (!root) throw new Error(`No AFF schema root available for ${type}`);
+	const file = findSchemaFile({
+		root,
+		type,
+		version
+	});
+	if (!file) throw new Error(`No AFF schema ${type}-v${version} under ${root}`);
+	return JSON.parse(readFileSync(file, "utf8"));
+}
+/**
+* Top-level body properties of a type's schema (everything beyond the
+* mandatory `formatVersion`/`header` envelope), newest version by default.
+* Empty array for header-only types or when schemas are unavailable.
+*/
+function affBodyProps(ref) {
+	let schema;
+	try {
+		schema = affSchema(ref);
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("No AFF schema")) return [];
+		throw error;
+	}
+	return Object.keys(schema.properties ?? {}).filter((p) => p !== "formatVersion" && p !== "header");
+}
+function affHeaderProps(ref) {
+	let schema;
+	try {
+		schema = affSchema(ref);
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("No AFF schema")) return [];
+		throw error;
+	}
+	const header = (schema.properties ?? {}).header;
+	return Object.keys(header && typeof header === "object" && header.properties ? header.properties : {});
+}
+const ajv = new Ajv2020({
+	allErrors: true,
+	strict: false
+});
+const validators = /* @__PURE__ */ new Map();
+/** Resolve a usable schema version, or `undefined` when none exists. */
+function resolveAffVersion(type, v) {
+	const resolved = v ?? latestAffVersion({ type });
+	return resolved !== void 0 && Number.isInteger(resolved) && resolved > 0 ? resolved : void 0;
+}
+/** Compile (and cache) the AJV validator for a type+version. */
+function getValidator(type, version) {
+	const key = `${type}-v${version}`;
+	const cached = validators.get(key);
+	if (cached) return { validator: cached };
+	try {
+		const validator = ajv.compile(affSchema({
+			type,
+			version
+		}));
+		validators.set(key, validator);
+		return { validator };
+	} catch (e) {
+		return { error: e instanceof Error ? e.message : String(e) };
+	}
+}
+/** Validate AFF JSON against the official schema for `ref`. */
+function affValidate(ref, json) {
+	const type = ref.type.toLowerCase();
+	const v = resolveAffVersion(type, ref.version);
+	if (v === void 0) return {
+		valid: false,
+		errors: [`No AFF schema for type "${type}"`]
+	};
+	const { validator, error } = getValidator(type, v);
+	if (!validator) return {
+		valid: false,
+		errors: [error ?? "schema compile failed"]
+	};
+	return {
+		valid: !!validator(json),
+		errors: (validator.errors ?? []).map((e) => `${e.instancePath} ${e.message ?? ""}`.trim())
+	};
+}
+/**
+* Example JSON files shipped with a type — recursively, relative paths.
+* Companion files (`.docu.json`, LIMU sub-objects like `.reps.json`) are
+* included; callers match each to its schema (see `schemaTargetForExample`).
+*/
+function affExamples(ref) {
+	const root = affRoot();
+	if (!root) return [];
+	const dir = join(root, ref.type.toLowerCase(), "examples");
+	if (!existsSync(dir)) return [];
+	const out = [];
+	const walk = (sub) => {
+		for (const e of readdirSync(join(dir, sub), { withFileTypes: true })) {
+			const rel = sub ? `${sub}/${e.name}` : e.name;
+			if (e.isDirectory()) walk(rel);
+			else if (e.name.endsWith(".json")) out.push(rel);
+		}
+	};
+	walk("");
+	return out.sort((a, b) => a.localeCompare(b));
+}
+/**
+* Pick the schema a given example file should validate against.
+*
+* - `z_x.doma.docu.json` → the `docu` schema (companion documentation)
+* - otherwise → the type's own schema at the example's `formatVersion`
+*/
+function schemaTargetForExample(ref, filename, json) {
+	if (/\.docu\.json$/i.test(filename) && affVersions({ type: "docu" }).length) return {
+		type: "docu",
+		companion: true
+	};
+	const declared = json?.formatVersion;
+	const version = declared !== void 0 ? Number(declared) : void 0;
+	return {
+		type: ref.type,
+		version,
+		companion: false
+	};
+}
+function readAffExample(ref, rel) {
+	const root = affRoot();
+	if (!root) throw new Error("No AFF schema root available");
+	const examplesDir = resolve(root, ref.type.toLowerCase(), "examples");
+	const file = resolve(examplesDir, rel);
+	if (file !== examplesDir && !file.startsWith(examplesDir + sep)) throw new Error(`Example path escapes examples dir: ${rel}`);
+	return JSON.parse(readFileSync(file, "utf8"));
+}
+
+// src/lib/aff/generic.ts
+/**
+* Schema-aware generic AFF emit/parse — zero workspace deps.
+*
+* `genericToMetadata` builds the `{formatVersion, header}` envelope for a
+* type (version pinned to its latest schema) plus only the schema-
+* declared top-level body properties the payload carries — arbitrary
+* payload fields are NOT copied. `genericFromMetadata` is its inverse:
+* header → ADK projection, body fields spread into the payload so they
+* land back on `obj.data` — enabling metadata round-trips for all
+* wave2-registered types.
+*/
+/**
+* Payload extraction that works for both plain objects (`data` is a
+* record) and real ADK objects (`data` is an async method; the loaded
+* payload lives behind the `dataSync` getter / `_data` field). Returns
+* `undefined` when no usable payload is found — callers fall back to
+* treating the object itself as the record.
+*/
+function isRecord(v) {
+	return !!v && typeof v === "object" && !Array.isArray(v);
+}
+/** Narrow to string/number; objects never reach `String()` coercion. */
+function str(v) {
+	return typeof v === "string" || typeof v === "number" ? String(v) : void 0;
+}
+/** ADK-object payload: `dataSync` getter (throws unloaded) or `_data`. */
+function adkPayloadOf(obj) {
+	try {
+		const sync = obj.dataSync;
+		if (isRecord(sync)) return sync;
+	} catch {}
+	const priv = obj._data;
+	return isRecord(priv) ? priv : void 0;
+}
+function payloadOf(obj) {
+	const d = obj.data;
+	if (isRecord(d)) return d;
+	if (typeof d === "function") return adkPayloadOf(obj);
+}
+function genericToMetadata(type) {
+	return (obj) => {
+		const data = payloadOf(obj) ?? obj;
+		const declared = data.formatVersion;
+		const version = typeof declared === "string" || typeof declared === "number" ? String(declared) : String(latestAffVersion({ type }) ?? "1");
+		const bodyProps = affBodyProps({
+			type,
+			version: Number.isNaN(Number(version)) ? void 0 : Number(version)
+		});
+		const headerProps = affHeaderProps({
+			type,
+			version: Number.isNaN(Number(version)) ? void 0 : Number(version)
+		});
+		const meta = {
+			formatVersion: version,
+			header: { originalLanguage: (obj.originalLanguage ?? str(data.originalLanguage) ?? str(data.language) ?? str(data.masterLanguage) ?? "en").toLowerCase() }
+		};
+		if (headerProps.length === 0 || headerProps.includes("description")) meta.header.description = str(data.description) ?? obj.description ?? obj.name;
+		const abapLang = str(data.abapLanguageVersion) ?? obj.abapLanguageVersion;
+		if (abapLang && abapLang !== "standard" && (headerProps.length === 0 || headerProps.includes("abapLanguageVersion"))) meta.header.abapLanguageVersion = abapLang;
+		for (const prop of bodyProps) {
+			const value = data[prop];
+			if (value !== void 0) meta[prop] = value;
+		}
+		return meta;
+	};
+}
+/**
+* Companion-source emit for source-bearing types (`.abap`, `.acds`,
+* `.csn`, …): reads `obj.sources` — `main` emits the suffix-less file,
+* other keys emit `{name}.{type}.{suffix}.{ext}`. A key ending in a file
+* extension selects that extension instead of the type default
+* (`z_func.func.json` → LIMU metadata, `texts.en.properties` → texts).
+* Falls back to `obj.getSource()` as the single `main` source.
+*/
+function genericGetSources(obj) {
+	const sources = payloadOf(obj)?.sources ?? obj.sources ?? obj._pendingSources;
+	const single = obj._pendingSource;
+	const merged = single ? {
+		main: single,
+		...sources
+	} : sources;
+	if (merged && Object.keys(merged).length > 0) return Object.entries(merged).filter(([, content]) => !!content).map(([key, content]) => ({
+		...splitSourceKey(key),
+		content
+	}));
+	const getSource = obj.getSource;
+	const src = typeof getSource === "function" ? getSource.call(obj) : void 0;
+	return src ? [{
+		suffix: void 0,
+		content: src
+	}] : [];
+}
+/**
+* DOCU companion emit: `data.docu` carries the raw DOCU JSON document —
+* emitted as `{name}.{type}.docu.json` beside the main metadata file
+* (AFF spec: DOCU is companion metadata, not a standalone object).
+*/
+function genericGetExtraFiles(type) {
+	return (obj) => {
+		const docu = payloadOf(obj)?.docu;
+		if (docu === void 0 || docu === null) return [];
+		const name = (obj.name ?? "").toLowerCase();
+		const content = typeof docu === "string" ? docu : JSON.stringify(docu, null, 2) + "\n";
+		return [{
+			path: `${name}.${type.toLowerCase()}.docu.json`,
+			content
+		}];
+	};
+}
+/**
+* Is `obj.data` assignable? Plain test doubles have a writable (or no)
+* `data` property — assignment creates/updates it. ADK objects expose
+* `data` as a method or a getter-only accessor (`AdkGenericObject`), where
+* assignment throws in strict mode; their mutable slot is `_data`.
+*/
+function dataIsWritable(obj) {
+	let cur = obj;
+	while (cur) {
+		const d = Object.getOwnPropertyDescriptor(cur, "data");
+		if (d) return "value" in d ? d.writable !== false : d.set !== void 0;
+		cur = Object.getPrototypeOf(cur);
+	}
+	return true;
+}
+/** Deserialize side: stage companion sources back onto the object. */
+function genericSetSources(obj, sources) {
+	const isAdkObject = typeof obj.data === "function" || !dataIsWritable(obj);
+	let data = payloadOf(obj);
+	if (!data) {
+		if (isAdkObject) {
+			const priv = obj;
+			priv._data = priv._data ?? {};
+			data = priv._data;
+		} else {
+			const fresh = {};
+			obj.data = fresh;
+			data = fresh;
+		}
+	}
+	const { docu, ...rest } = sources;
+	if (docu !== void 0) try {
+		data.docu = JSON.parse(docu);
+	} catch {
+		data.docu = docu;
+	}
+	data.sources = {
+		...data.sources,
+		...rest
+	};
+	if (isAdkObject) {
+		const pending = obj;
+		pending._pendingSources = {
+			...pending._pendingSources,
+			...rest
+		};
+	}
+}
+function genericFromMetadata(meta) {
+	const { formatVersion, header, ...body } = meta;
+	return {
+		name: "",
+		description: header.description,
+		language: header.originalLanguage?.toUpperCase(),
+		masterLanguage: header.originalLanguage?.toUpperCase(),
+		formatVersion,
+		...header.abapLanguageVersion ? { abapLanguageVersion: header.abapLanguageVersion } : {},
+		...body
+	};
+}
+
 // src/lib/handlers/base.ts
 const handlerRegistry = /* @__PURE__ */ new Map();
 /** Look up a handler (full-type first, then main-type fallback). */
@@ -139,6 +673,67 @@ function getSupportedTypes() {
 function buildMetadataFile(meta) {
 	return JSON.stringify(meta, null, 2) + "\n";
 }
+/** Staged source companions → files (extension-aware keys → LIMU names). */
+function sourceCompanionFiles(object, type, objectName, suffixToSourceKey) {
+	const payload = payloadOf(object);
+	const pending = object;
+	const map = {
+		...payload?.sources,
+		...pending._pendingSources
+	};
+	if (pending._pendingSource && !map.main) map.main = pending._pendingSource;
+	const keyToSuffix = Object.fromEntries(Object.entries(suffixToSourceKey ?? {}).map(([suffix, key]) => [key, suffix]));
+	const files = [];
+	for (const [key, content] of Object.entries(map)) {
+		if (content == null) continue;
+		const { suffix, ext } = splitSourceKey(key);
+		const fileSuffix = suffix ? keyToSuffix[suffix] ?? suffix : suffix;
+		files.push({
+			path: gctsFilename(objectName, type, "source", fileSuffix, ext),
+			content
+		});
+	}
+	return files;
+}
+/** `data.docu` → `{name}.{type}.docu.json` file (or nothing). */
+function docuCompanionFile(payload, objectName, typeLower) {
+	const docu = payload?.docu;
+	if (docu === void 0 || docu === null) return [];
+	return [{
+		path: `${objectName}.${typeLower}.docu.json`,
+		content: typeof docu === "string" ? docu : JSON.stringify(docu, null, 2) + "\n"
+	}];
+}
+/** `data.properties` map → `.properties` files ('' key → master file). */
+function propertyCompanionFiles(payload, objectName, typeLower) {
+	const props = payload?.properties;
+	const files = [];
+	for (const [key, content] of Object.entries(props ?? {})) {
+		if (content == null) continue;
+		files.push({
+			path: key ? `${objectName}.${typeLower}.${key}.properties` : `${objectName}.${typeLower}.properties`,
+			content
+		});
+	}
+	return files;
+}
+/**
+* Universal companion preservation. Deserialization stages every
+* companion a dedicated hook does not claim into `_pendingSources` /
+* `data.sources` (extension-aware keys), `data.docu`, and
+* `data.properties` — emitted here so handlers without a matching emit
+* hook still round-trip LIMU sub-objects, DOCU texts, and translations
+* instead of silently dropping them. Paths already in `emitted` win.
+*/
+function companionFiles(object, type, objectName, emitted, suffixToSourceKey) {
+	const typeLower = type.split("/")[0].toLowerCase();
+	const payload = payloadOf(object);
+	return [
+		...sourceCompanionFiles(object, type, objectName, suffixToSourceKey),
+		...docuCompanionFile(payload, objectName, typeLower),
+		...propertyCompanionFiles(payload, objectName, typeLower)
+	].filter((f) => !emitted.has(f.path));
+}
 function createHandler(adkClassOrType, definition) {
 	let type;
 	if (typeof adkClassOrType === "string") type = adkClassOrType;
@@ -167,7 +762,7 @@ function createHandler(adkClassOrType, definition) {
 				const content = await resolveSource(entry);
 				if (!content) continue;
 				files.push({
-					path: gctsFilename(objectName, type, "source", entry.suffix),
+					path: gctsFilename(objectName, type, "source", entry.suffix, entry.ext),
 					content
 				});
 			}
@@ -195,6 +790,7 @@ function createHandler(adkClassOrType, definition) {
 					});
 				}
 			}
+			files.push(...companionFiles(object, type, objectName, new Set(files.map((f) => f.path)), definition.suffixToSourceKey));
 			return files;
 		},
 		fromAbapGit: definition.fromMetadata ? (values) => definition.fromMetadata(values) : void 0,
@@ -676,9 +1272,10 @@ const tableTypeHandler = createHandler(AdkTableType, {
 *
 * AFF's FUGR representation nests function modules under the group
 * 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
+* files when function module data is available (LIMU naming keeps the
+* submodule files inside the parent's namespace):
+*   <parent>.fugr.<fmname>.func.json — FM metadata (func-v1.json schema)
+*   <parent>.fugr.<fmname>.func.abap — FM source
 */
 function buildFuncMetadata(fm) {
 	const meta = {
@@ -706,14 +1303,15 @@ const functionGroupHandler = createHandler(AdkFunctionGroup, {
 	getExtraFiles(fugr) {
 		const fms = fugr.functionModules ?? [];
 		const files = [];
+		const parent = affName(fugr.name ?? "");
 		for (const fm of fms) {
-			const fmName = fm.name.toLowerCase();
+			const fmName = affName(fm.name);
 			files.push({
-				path: `${fmName}.func.json`,
+				path: `${parent}.fugr.${fmName}.func.json`,
 				content: buildFuncMetadata(fm)
 			});
 			if (fm.source) files.push({
-				path: `${fmName}.func.abap`,
+				path: `${parent}.fugr.${fmName}.func.abap`,
 				content: fm.source
 			});
 		}
@@ -954,40 +1552,18 @@ const messageClassHandler = createHandler("MSAG", {
 /**
 * 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 } }
+* Wave 2 mass-registers handlers for all AFF types that have JSON schemas
+* but no dedicated handler. Each stub runs the schema-aware generic
+* emit/parse from `../../aff/generic`: the `{formatVersion, header}`
+* envelope at the type's latest schema version plus every top-level body
+* property present in the payload — schema-valid whenever the payload is.
 *
-* 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.
+* Types needing semantic mapping, source companions, or special file
+* shapes graduate to a dedicated file (like clas.ts, ddls.ts, …).
 *
 * 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",
@@ -1065,9 +1641,11 @@ for (const type of [
 	"UIPG",
 	"UIST"
 ]) createHandler(type, {
-	toMetadata,
-	getSource,
-	fromMetadata
+	toMetadata: genericToMetadata(type.toLowerCase()),
+	getSources: genericGetSources,
+	getExtraFiles: genericGetExtraFiles(type.toLowerCase()),
+	fromMetadata: genericFromMetadata,
+	setSources: genericSetSources
 });
 
 // src/lib/format/gcts-format.ts
@@ -1086,11 +1664,19 @@ const gctsFormatPlugin = {
 };
 
 // src/lib/deserializer.ts
-/** Source-file extensions emitted by gCTS handlers. */
+/** Source-file extensions emitted by gCTS handlers. `.properties`
+* translation files are deliberately excluded — they are companions
+* routed into `data.properties`, never ABAP source staging. */
 const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 	"abap",
 	"asddls",
-	"asdcls"
+	"asdcls",
+	"acds",
+	"abdl",
+	"csn",
+	"xdp",
+	"ddic",
+	"xml"
 ]);
 /**
 * Map numeric abapLanguageVersion codes (`'5'` etc.) to the descriptive
@@ -1131,9 +1717,28 @@ async function* deserialize(fileTree, client, options) {
 		if (!objectMap.has(key)) objectMap.set(key, {
 			name: parsed.name.toUpperCase(),
 			type: parsed.type.toUpperCase(),
-			sourceFiles: []
+			sourceFiles: [],
+			propertyFiles: []
+		});
+		if (parsed.suffix === "docu") objectMap.get(key).docuFile = jsonPath;
+		else if (parsed.suffix) {
+			objectMap.get(key).sourceFiles.push({
+				path: jsonPath,
+				suffix: parsed.suffix,
+				ext: "json"
+			});
+			continue;
+		} else objectMap.get(key).metadataFile = jsonPath;
+	}
+	for (const path of await fileTree.glob("**/*.properties")) {
+		const filename = path.split("/").pop();
+		const parsed = parseGctsFilename(filename);
+		if (!parsed) continue;
+		const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
+		objectMap.get(key)?.propertyFiles.push({
+			path,
+			suffix: parsed.suffix
 		});
-		objectMap.get(key).metadataFile = jsonPath;
 	}
 	for (const ext of SOURCE_EXTENSIONS) {
 		const paths = await fileTree.glob(`**/*.${ext}`);
@@ -1146,51 +1751,128 @@ async function* deserialize(fileTree, client, options) {
 			if (!obj) continue;
 			obj.sourceFiles.push({
 				path,
-				suffix: parsed.suffix
+				suffix: parsed.suffix,
+				ext: parsed.extension
 			});
 		}
 	}
+	const fileContents = /* @__PURE__ */ new Map();
+	const readErrors = /* @__PURE__ */ new Map();
+	const companionPaths = [...objectMap.values()].flatMap((o) => [
+		...o.docuFile ? [o.docuFile] : [],
+		...o.propertyFiles.map((f) => f.path),
+		...o.sourceFiles.map((f) => f.path)
+	]);
+	const READ_BATCH = 32;
+	let cursor = 0;
+	const readNext = async () => {
+		const path = companionPaths[cursor++];
+		if (path === void 0) return;
+		try {
+			fileContents.set(path, await fileTree.read(path));
+		} catch (error) {
+			readErrors.set(path, error);
+		}
+		return readNext();
+	};
+	await Promise.all(Array.from({ length: Math.min(READ_BATCH, companionPaths.length) }, readNext));
 	for (const [, objFiles] of objectMap) {
 		if (!objFiles.metadataFile) continue;
 		const handler = getHandler(objFiles.type);
 		if (!handler) continue;
 		try {
 			const raw = await fileTree.read(objFiles.metadataFile);
-			const metadata = handler.schema.parse(raw);
-			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(metadata) : { name: objFiles.name };
-			const objectName = payload.name || objFiles.name;
-			const fullData = {
-				...payload,
-				name: objectName
-			};
-			const adkType = typeof payload.type === "string" ? payload.type : objFiles.type;
-			const adkObject = adk.getWithData(fullData, adkType);
-			if (Object.keys(sources).length > 0) {
-				if (handler.setSources) handler.setSources(adkObject, sources);
-				else if (sources.main) adkObject._pendingSource = sources.main;
-			}
-			if (payload.description) adkObject._pendingDescription = payload.description;
-			adkObject._relDir = objFiles.metadataFile.split("/").slice(0, -1).join("/");
-			if (options?.rootPackage) {
-				const data = adkObject._data;
-				if (data && !data.packageRef) data.packageRef = { name: options.rootPackage };
-			}
-			if (options?.abapLanguageVersion) {
-				const data = adkObject._data;
-				if (data && !data.abapLanguageVersion) data.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
-			}
-			yield adkObject;
+			yield objectFromFiles(objFiles, handler, handler.schema.parse(raw), fileContents, readErrors, adk, options);
 		} catch (error) {
 			console.error(`Failed to deserialize ${objFiles.type} ${objFiles.name}:`, error);
 		}
 	}
 }
+/**
+* Read the collected source/companion files into a source-key map.
+* Companions whose extension differs from the type's default encode it
+* into the key (`{suffix}.{ext}`) — LIMU `.json` metadata and
+* `.properties` texts stay distinguishable from `.abap` sources.
+*/
+function collectSources(objFiles, handler, contents) {
+	const sources = {};
+	for (const { path, suffix, ext } of objFiles.sourceFiles) {
+		const content = contents.get(path);
+		if (content === void 0) continue;
+		let key;
+		if (suffix) key = sourceKey(objFiles.type, handler.suffixToSourceKey?.[suffix] ?? suffix, ext ?? "");
+		else if (ext && ext !== "json") key = sourceKey(objFiles.type, "main", ext);
+		else key = "main";
+		sources[key] = content;
+	}
+	return sources;
+}
+/**
+* Stage companion keys on an ADK object without a dedicated
+* `setSources` hook — everything lands on `_pendingSources` /
+* `_pendingSource` so the shared emit path in `base.ts` re-emits
+* LIMU/sub-object files instead of silently dropping them.
+*/
+function stagePendingSources(adkObject, sources) {
+	const staged = adkObject;
+	const { main, ...rest } = sources;
+	if (main !== void 0) staged._pendingSource = main;
+	if (Object.keys(rest).length > 0) staged._pendingSources = {
+		...staged._pendingSources,
+		...rest
+	};
+}
+/** Build the payload record: handler projection + docu + properties. */
+function buildPayload(objFiles, handler, metadata, contents) {
+	const payload = handler.fromAbapGit ? handler.fromAbapGit(metadata) : { name: objFiles.name };
+	const docuRaw = objFiles.docuFile ? contents.get(objFiles.docuFile) : void 0;
+	if (docuRaw !== void 0) try {
+		payload.docu = JSON.parse(docuRaw);
+	} catch {
+		payload.docu = docuRaw;
+	}
+	if (objFiles.propertyFiles.length > 0) {
+		const props = {};
+		for (const { path, suffix } of objFiles.propertyFiles) {
+			const content = contents.get(path);
+			if (content !== void 0) props[suffix ?? ""] = content;
+		}
+		payload.properties = props;
+	}
+	return payload;
+}
+/** Merge `data.packageRef`/`abapLanguageVersion` fallbacks onto the object. */
+function applyOptionsFallbacks(adkObject, options) {
+	const data = adkObject._data;
+	if (!data) return;
+	if (options?.rootPackage && !data.packageRef) data.packageRef = { name: options.rootPackage };
+	if (options?.abapLanguageVersion && !data.abapLanguageVersion) data.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
+}
+/** Metadata + collected files → a staged ADK object. */
+function objectFromFiles(objFiles, handler, metadata, contents, readErrors, adk, options) {
+	for (const path of [
+		...objFiles.docuFile ? [objFiles.docuFile] : [],
+		...objFiles.propertyFiles.map((f) => f.path),
+		...objFiles.sourceFiles.map((f) => f.path)
+	]) if (readErrors.has(path)) throw readErrors.get(path);
+	const sources = collectSources(objFiles, handler, contents);
+	const payload = buildPayload(objFiles, handler, metadata, contents);
+	const objectName = payload.name || objFiles.name;
+	const fullData = {
+		...payload,
+		name: objectName
+	};
+	const adkType = typeof payload.type === "string" ? payload.type : objFiles.type;
+	const adkObject = adk.getWithData(fullData, adkType);
+	if (Object.keys(sources).length > 0) {
+		if (handler.setSources) handler.setSources(adkObject, sources);
+		else stagePendingSources(adkObject, sources);
+	}
+	if (payload.description) adkObject._pendingDescription = payload.description;
+	adkObject._relDir = objFiles.metadataFile.split("/").slice(0, -1).join("/");
+	applyOptionsFallbacks(adkObject, options);
+	return adkObject;
+}
 
 // src/lib/gcts-plugin.ts
 /**
@@ -1251,6 +1933,382 @@ const gctsPlugin = createPlugin({
 	}
 });
 
+// src/schemas/generated/advc-v1.ts
+var advc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifa-v1.ts
+var aifa_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifd-v1.ts
+var aifd_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aiff-v1.ts
+var aiff_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifi-v1.ts
+var aifi_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifn-v1.ts
+var aifn_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifp-v1.ts
+var aifp_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aifr-v1.ts
+var aifr_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aobj-v1.ts
+var aobj_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/apic-v1.ts
+var apic_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/aplo-v1.ts
+var aplo_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/apob-v1.ts
+var apob_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/bdef-v1.ts
+var bdef_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/bgqc-v1.ts
+var bgqc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/cdbo-v1.ts
+var cdbo_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/cfdf-v1.ts
+var cfdf_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/cfdf-v2.ts
+var cfdf_v2_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/chdo-v1.ts
+var chdo_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/chkc-v1.ts
+var chkc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/chko-v1.ts
+var chko_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/chkv-v1.ts
+var chkv_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/clas-v1.ts
+var clas_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/cota-v1.ts
+var cota_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/csnm-v1.ts
+var csnm_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dcat-v1.ts
+var dcat_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dcls-v1.ts
+var dcls_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ddla-v1.ts
+var ddla_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ddls-v1.ts
+var ddls_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ddlx-v1.ts
+var ddlx_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/desd-v1.ts
+var desd_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dmon-v1.ts
+var dmon_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dobj-v1.ts
+var dobj_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/docu-v1.ts
+var docu_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/doma-v1.ts
+var doma_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dras-v1.ts
+var dras_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/drty-v1.ts
+var drty_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dsfd-v1.ts
+var dsfd_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dsfi-v1.ts
+var dsfi_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dtdc-v1.ts
+var dtdc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dteb-v1.ts
+var dteb_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dtel-v1.ts
+var dtel_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dtix-v1.ts
+var dtix_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/dtsc-v1.ts
+var dtsc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/edcc-v1.ts
+var edcc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/edck-v1.ts
+var edck_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/edcr-v1.ts
+var edcr_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/edoi-v1.ts
+var edoi_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/eeec-v1.ts
+var eeec_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/enho-v1.ts
+var enho_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/enhs-v1.ts
+var enhs_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/enqu-v1.ts
+var enqu_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/evtb-v1.ts
+var evtb_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/evto-v1.ts
+var evto_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/fugr-v1.ts
+var fugr_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/func-v1.ts
+var func_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/gsmp-v1.ts
+var gsmp_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/http-v1.ts
+var http_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ilmb-v1.ts
+var ilmb_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/intf-v1.ts
+var intf_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/intm-v1.ts
+var intm_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ints-v1.ts
+var ints_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/iwng-v1.ts
+var iwng_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/msag-v1.ts
+var msag_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/nont-v1.ts
+var nont_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/nrob-v1.ts
+var nrob_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ntta-v1.ts
+var ntta_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ntty-v1.ts
+var ntty_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/prog-v1.ts
+var prog_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/reps-v1.ts
+var reps_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/ront-v1.ts
+var ront_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/rvbc-v1.ts
+var rvbc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/saia-v1.ts
+var saia_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sajc-v1.ts
+var sajc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sajt-v1.ts
+var sajt_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/scp1-v1.ts
+var scp1_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sfpf-v1.ts
+var sfpf_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/siad-v1.ts
+var siad_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sito-v1.ts
+var sito_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sito-v2.ts
+var sito_v2_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/smbc-v1.ts
+var smbc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/smtg-v1.ts
+var smtg_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sprv-v1.ts
+var sprv_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/srvb-v1.ts
+var srvb_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/srvc-v1.ts
+var srvc_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/srvd-v1.ts
+var srvd_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/suco-v1.ts
+var suco_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/susi-v1.ts
+var susi_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/swcr-v1.ts
+var swcr_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/sxtg-v1.ts
+var sxtg_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/uiad-v1.ts
+var uiad_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/uiad-v2.ts
+var uiad_v2_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/uipg-v1.ts
+var uipg_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/uist-v1.ts
+var uist_v1_exports = /* @__PURE__ */ __exportAll({});
+
+// src/schemas/generated/index.ts
+var generated_exports = /* @__PURE__ */ __exportAll({
+	AdvcV1: () => advc_v1_exports,
+	AifaV1: () => aifa_v1_exports,
+	AifdV1: () => aifd_v1_exports,
+	AiffV1: () => aiff_v1_exports,
+	AifiV1: () => aifi_v1_exports,
+	AifnV1: () => aifn_v1_exports,
+	AifpV1: () => aifp_v1_exports,
+	AifrV1: () => aifr_v1_exports,
+	AobjV1: () => aobj_v1_exports,
+	ApicV1: () => apic_v1_exports,
+	AploV1: () => aplo_v1_exports,
+	ApobV1: () => apob_v1_exports,
+	BdefV1: () => bdef_v1_exports,
+	BgqcV1: () => bgqc_v1_exports,
+	CdboV1: () => cdbo_v1_exports,
+	CfdfV1: () => cfdf_v1_exports,
+	CfdfV2: () => cfdf_v2_exports,
+	ChdoV1: () => chdo_v1_exports,
+	ChkcV1: () => chkc_v1_exports,
+	ChkoV1: () => chko_v1_exports,
+	ChkvV1: () => chkv_v1_exports,
+	ClasV1: () => clas_v1_exports,
+	CotaV1: () => cota_v1_exports,
+	CsnmV1: () => csnm_v1_exports,
+	DcatV1: () => dcat_v1_exports,
+	DclsV1: () => dcls_v1_exports,
+	DdlaV1: () => ddla_v1_exports,
+	DdlsV1: () => ddls_v1_exports,
+	DdlxV1: () => ddlx_v1_exports,
+	DesdV1: () => desd_v1_exports,
+	DmonV1: () => dmon_v1_exports,
+	DobjV1: () => dobj_v1_exports,
+	DocuV1: () => docu_v1_exports,
+	DomaV1: () => doma_v1_exports,
+	DrasV1: () => dras_v1_exports,
+	DrtyV1: () => drty_v1_exports,
+	DsfdV1: () => dsfd_v1_exports,
+	DsfiV1: () => dsfi_v1_exports,
+	DtdcV1: () => dtdc_v1_exports,
+	DtebV1: () => dteb_v1_exports,
+	DtelV1: () => dtel_v1_exports,
+	DtixV1: () => dtix_v1_exports,
+	DtscV1: () => dtsc_v1_exports,
+	EdccV1: () => edcc_v1_exports,
+	EdckV1: () => edck_v1_exports,
+	EdcrV1: () => edcr_v1_exports,
+	EdoiV1: () => edoi_v1_exports,
+	EeecV1: () => eeec_v1_exports,
+	EnhoV1: () => enho_v1_exports,
+	EnhsV1: () => enhs_v1_exports,
+	EnquV1: () => enqu_v1_exports,
+	EvtbV1: () => evtb_v1_exports,
+	EvtoV1: () => evto_v1_exports,
+	FugrV1: () => fugr_v1_exports,
+	FuncV1: () => func_v1_exports,
+	GsmpV1: () => gsmp_v1_exports,
+	HttpV1: () => http_v1_exports,
+	IlmbV1: () => ilmb_v1_exports,
+	IntfV1: () => intf_v1_exports,
+	IntmV1: () => intm_v1_exports,
+	IntsV1: () => ints_v1_exports,
+	IwngV1: () => iwng_v1_exports,
+	MsagV1: () => msag_v1_exports,
+	NontV1: () => nont_v1_exports,
+	NrobV1: () => nrob_v1_exports,
+	NttaV1: () => ntta_v1_exports,
+	NttyV1: () => ntty_v1_exports,
+	ProgV1: () => prog_v1_exports,
+	RepsV1: () => reps_v1_exports,
+	RontV1: () => ront_v1_exports,
+	RvbcV1: () => rvbc_v1_exports,
+	SaiaV1: () => saia_v1_exports,
+	SajcV1: () => sajc_v1_exports,
+	SajtV1: () => sajt_v1_exports,
+	Scp1V1: () => scp1_v1_exports,
+	SfpfV1: () => sfpf_v1_exports,
+	SiadV1: () => siad_v1_exports,
+	SitoV1: () => sito_v1_exports,
+	SitoV2: () => sito_v2_exports,
+	SmbcV1: () => smbc_v1_exports,
+	SmtgV1: () => smtg_v1_exports,
+	SprvV1: () => sprv_v1_exports,
+	SrvbV1: () => srvb_v1_exports,
+	SrvcV1: () => srvc_v1_exports,
+	SrvdV1: () => srvd_v1_exports,
+	SucoV1: () => suco_v1_exports,
+	SusiV1: () => susi_v1_exports,
+	SwcrV1: () => swcr_v1_exports,
+	SxtgV1: () => sxtg_v1_exports,
+	UiadV1: () => uiad_v1_exports,
+	UiadV2: () => uiad_v2_exports,
+	UipgV1: () => uipg_v1_exports,
+	UistV1: () => uist_v1_exports
+});
+
 // src/index.ts
 /**
 * @abapify/adt-plugin-gcts — gCTS / AFF format plugin entry point.
@@ -1265,5 +2323,5 @@ registerFormatPlugin({
 	id: "aff"
 });
 
-export { gctsPlugin as GctsPlugin, gctsPlugin as default, gctsPlugin, METADATA_EXTENSION, PACKAGE_FILENAME, adtUriToGctsPath, createHandler, gctsFilename, gctsFormatPlugin, getHandler, getSupportedTypes, isSupported, parseGctsFilename };
+export { generated_exports as AffGenerated, gctsPlugin as GctsPlugin, gctsPlugin as default, gctsPlugin, LIMU_SUBTYPES, METADATA_EXTENSION, PACKAGE_FILENAME, adtUriToGctsPath, affBodyProps, affExamples, affRoot, affSchema, affValidate, affVersions, createHandler, gctsFilename, gctsFormatPlugin, gctsSourceExt, getHandler, getSupportedTypes, isSupported, latestAffVersion, listAffTypes, parseGctsFilename, readAffExample, schemaTargetForExample, sourceKey, splitSourceKey };
 //# sourceMappingURL=index.mjs.map