@abapify/adk 0.3.6 → 0.4.1

package/dist/index.mjs

@@ -0,0 +1,4300 @@
+import { A as Package, C as Domain, D as Include, E as FunctionModule, F as TransportRequest, I as TransportTask, M as Structure, N as Table, O as Interface, P as TableType, S as DataElement, T as FunctionGroup, _ as parseAdtType, a as parseXmlIdentity, b as resolveType, c as getKindForType, d as getObjectUri, f as getRegisteredKinds, g as normalizeObjectName, h as isTypeRegistered, j as Program, k as MessageClass, l as getMainType, m as getTypeForKind, n as createAdk, o as ADT_TYPE_MAPPINGS, p as getRegisteredTypes, r as createAdkFactory, s as getEndpointForType, t as AdkGenericObject, u as getObjectRootUri, v as registerObjectType, w as EnhancementSpot, x as Class, y as resolveKind } from "./factory-DtyrTGlN.mjs";
+import { createLockService, createLockService as createLockService$1 } from "@abapify/adt-locks";
+
+//#region src/base/fetch-utils.ts
+/**
+* Utility for handling v2 client fetch responses.
+*
+* The v2 ADT client's `fetch()` returns parsed data directly (a string for
+* text/plain content), not a standard `Response` object. This helper
+* normalises both cases so ADK objects work with both client versions.
+*/
+/**
+* Convert a fetch result to a text string.
+*
+* - If the result is already a string (v2 client), return it as-is.
+* - If the result is a Response-like object (v1 / standard fetch), call `.text()`.
+*/
+async function toText(result) {
+	if (typeof result === "string") return result;
+	if (result && typeof result === "object" && "text" in result && typeof result.text === "function") return result.text();
+	if (result === null || result === void 0) return "";
+	if (typeof result === "object") try {
+		return JSON.stringify(result);
+	} catch {
+		return String(result);
+	}
+	return String(result);
+}
+
+//#endregion
+//#region src/base/model.ts
+/**
+* Base class for all ADK objects
+*
+* All ADK objects (AdkPackage, AdkTransportRequest, etc.) extend this.
+* Supports deferred loading - create with just a name, then call load().
+*
+* Note: Uses loose type constraint for D to allow schema-inferred types
+* from contracts which may have different shapes. The getters safely
+* handle missing properties with defaults.
+*
+* @typeParam K - The object kind (from AdkKind)
+* @typeParam D - The internal data type (typically schema-inferred from contract)
+*/
+var AdkObject = class {
+	/**
+	* ADT collection URI - base path for creating new objects.
+	* Example: `/sap/bc/adt/oo/classes`
+	* Default: derived from objectUri by removing the object name
+	*/
+	get collectionUri() {
+		const uri = this.objectUri;
+		const lastSlash = uri.lastIndexOf("/");
+		return lastSlash > 0 ? uri.substring(0, lastSlash) : uri;
+	}
+	ctx;
+	/** Public access to the ADT client for plugins and external code */
+	get client() {
+		return this.ctx.client;
+	}
+	_data;
+	_name;
+	cache = /* @__PURE__ */ new Map();
+	dirty = /* @__PURE__ */ new Set();
+	_lockHandle;
+	/** Set by save() when all pending changes are identical to SAP state */
+	_unchanged = false;
+	/**
+	* Create ADK object
+	* @param ctx - ADK context
+	* @param dataOrName - Full data object OR just the object name for deferred loading
+	*/
+	constructor(ctx, dataOrName) {
+		this.ctx = ctx;
+		if (typeof dataOrName === "string") this._name = dataOrName;
+		else {
+			this._data = dataOrName;
+			this._name = dataOrName.name;
+		}
+	}
+	/**
+	* Adopt a richer context (merge services into existing context).
+	*
+	* Used by AdkObjectSet to propagate lockService / lockStore
+	* to objects created by plugins that only have { client }.
+	* Keeps the original client reference intact.
+	*/
+	adoptContext(ctx) {
+		this.ctx = {
+			...this.ctx,
+			...ctx
+		};
+	}
+	/**
+	* Load object data from SAP
+	*
+	* Default implementation uses crudContract.get() and unwraps with wrapperKey.
+	* Objects without crudContract must override this.
+	*
+	* @returns this (for chaining)
+	*/
+	async load() {
+		const contract = this.crudContract;
+		const wrapperKey = this.wrapperKey;
+		if (!contract || !wrapperKey) throw new Error(`Load not implemented for ${this.kind}. Override load() or provide crudContract/wrapperKey.`);
+		const response = await contract.get(this.name);
+		if (!response || !(wrapperKey in response)) throw new Error(`${this.kind} '${this.name}' not found or returned empty response`);
+		this.setData(response[wrapperKey]);
+		return this;
+	}
+	/** Whether data has been loaded */
+	get isLoaded() {
+		return !!this._data;
+	}
+	/**
+	* Get data - auto-loads if not already loaded
+	* @returns Promise that resolves to the data
+	*/
+	async data() {
+		if (!this._data) await this.load();
+		return this._data;
+	}
+	/**
+	* Get data synchronously - throws if not loaded
+	* Use when you know data is already loaded
+	*/
+	get dataSync() {
+		if (!this._data) throw new Error(`${this.kind} '${this._name}' not loaded. Call load() or use data() instead.`);
+		return this._data;
+	}
+	/** Set data (for subclasses to use after loading) */
+	setData(data) {
+		this._data = data;
+		this._name = data.name;
+	}
+	/** Helper to access data with AdkObjectData properties */
+	get coreData() {
+		return this.dataSync;
+	}
+	/** ADT object name (adtcore:name) - available even before load() */
+	get name() {
+		return this._name;
+	}
+	/** ADT object type (adtcore:type, e.g. 'RQRQ', 'DEVC/K') - requires load() */
+	get type() {
+		return this.coreData.type;
+	}
+	/** Description text (adtcore:description) */
+	get description() {
+		return this.coreData.description ?? "";
+	}
+	/** Version state (adtcore:version) - active, inactive, etc. */
+	get version() {
+		return this.coreData.version ?? "";
+	}
+	/** Current language (adtcore:language) */
+	get language() {
+		return this.coreData.language ?? "";
+	}
+	/** User who last modified (adtcore:changedBy) */
+	get changedBy() {
+		return this.coreData.changedBy ?? "";
+	}
+	/** Last modification timestamp (adtcore:changedAt) */
+	get changedAt() {
+		const val = this.coreData.changedAt;
+		return val instanceof Date ? val : val ? new Date(val) : /* @__PURE__ */ new Date(0);
+	}
+	/** User who created (adtcore:createdBy) */
+	get createdBy() {
+		return this.coreData.createdBy ?? "";
+	}
+	/** Creation timestamp (adtcore:createdAt) */
+	get createdAt() {
+		const val = this.coreData.createdAt;
+		return val instanceof Date ? val : val ? new Date(val) : /* @__PURE__ */ new Date(0);
+	}
+	/** All atom:link elements */
+	get links() {
+		return this.coreData.links ?? [];
+	}
+	/** Find link by rel attribute */
+	getLink(rel) {
+		return this.links.find((l) => l.rel === rel);
+	}
+	/** Get link href by rel, or undefined */
+	getLinkHref(rel) {
+		return this.getLink(rel)?.href;
+	}
+	/** Container reference (adtcore:containerRef) */
+	get containerRef() {
+		return this.coreData.containerRef;
+	}
+	/** Check if object is currently locked */
+	get isLocked() {
+		return !!this._lockHandle;
+	}
+	/** Get current lock handle */
+	get lockHandle() {
+		return this._lockHandle;
+	}
+	/**
+	* Lock the object for modification
+	*
+	* Delegates to the lock service (single lock mechanism).
+	*
+	* The lock response contains:
+	* - LOCK_HANDLE: Required for subsequent PUT/unlock operations
+	* - CORRNR: Transport request assigned to this object (use for PUT if no explicit transport)
+	* - CORRUSER: User who owns the transport
+	*
+	* @param transport - Optional transport request to use for locking.
+	*                    Required when object is already in a transport.
+	*/
+	async lock(transport) {
+		if (this._lockHandle) return this._lockHandle;
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error(`Lock not available: no lockService in context. Did you call initializeAdk()?`);
+		this._lockHandle = await lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: this.kind
+		});
+		return this._lockHandle;
+	}
+	/**
+	* Unlock the object
+	*
+	* Delegates to the lock service (single lock mechanism).
+	*/
+	async unlock() {
+		if (!this._lockHandle) return;
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error(`Unlock not available: no lockService in context. Did you call initializeAdk()?`);
+		await lockService.unlock(this.objectUri, { lockHandle: this._lockHandle.handle });
+		this._lockHandle = void 0;
+	}
+	/**
+	* Set lock handle (for subclasses that need custom lock logic)
+	*/
+	setLockHandle(handle) {
+		this._lockHandle = handle;
+	}
+	/**
+	* Save the object to SAP
+	*
+	* Generic implementation that handles:
+	* - Lock/unlock lifecycle
+	* - Mode switching (create/update/upsert)
+	* - Error handling
+	*
+	* Subclasses implement `saveViaContract()` to provide the typed contract call.
+	*
+	* Modes:
+	* - 'update' (default): PUT to existing object
+	* - 'create': POST skeleton, then lock → PUT/source → unlock (Eclipse ADT pattern)
+	* - 'upsert': Check existence, create if needed, then update
+	*
+	* @param options - Save options
+	* @returns this (for chaining)
+	*/
+	async save(options = {}) {
+		const { transport, mode = "update" } = options;
+		this._unchanged = false;
+		if (mode === "create") {
+			if (!await this.checkObjectExists()) await this.saveViaContract("create", { transport });
+			return this.save({
+				...options,
+				mode: "update"
+			});
+		}
+		const hasPendingSources = this.hasPendingSources();
+		if (hasPendingSources) {
+			await this.checkPendingSourcesUnchanged();
+			if (this._unchanged) return this;
+		}
+		if (!hasPendingSources) {
+			await this.checkMetadataUnchanged();
+			if (this._unchanged) return this;
+		}
+		let confirmedExists = false;
+		if (mode === "upsert") {
+			confirmedExists = await this.checkObjectExists();
+			if (!confirmedExists) return this.fallbackToCreate(options);
+		}
+		const wasLocked = this.isLocked;
+		if (!wasLocked) try {
+			await this.lock(transport);
+		} catch (e) {
+			if (mode === "upsert" && !confirmedExists && this.shouldFallbackToCreate(e)) return this.fallbackToCreate(options);
+			throw e;
+		}
+		try {
+			const effectiveTransport = transport ?? this._lockHandle?.correlationNumber;
+			if (!wasLocked) await this.refreshETagsAfterLock();
+			if (hasPendingSources) await this.savePendingSources({
+				lockHandle: this._lockHandle?.handle,
+				transport: effectiveTransport
+			});
+			else {
+				const effectiveMode = mode === "upsert" ? "update" : mode;
+				await this.saveViaContract(effectiveMode, {
+					transport: effectiveTransport,
+					lockHandle: this._lockHandle?.handle
+				});
+			}
+			this.dirty.clear();
+			return this;
+		} catch (e) {
+			if (mode === "upsert" && this.shouldFallbackToCreate(e)) {
+				if (!wasLocked) try {
+					await this.unlock();
+				} catch {}
+				return this.fallbackToCreate(options);
+			}
+			if (mode === "upsert" && this.isAlreadyExistsError(e)) {
+				this._unchanged = true;
+				return this;
+			}
+			throw e;
+		} finally {
+			if (!wasLocked) await this.unlock();
+		}
+	}
+	/**
+	* Wrapper key for the data in contract requests/responses
+	*
+	* Contracts wrap data like { abapClass: ... } or { abapInterface: ... }.
+	* Subclasses that support save override this.
+	*/
+	get wrapperKey() {}
+	/**
+	* CRUD contract for this object type
+	*
+	* Subclasses that support save override this to return their contract.
+	*/
+	get crudContract() {}
+	/**
+	* Execute the typed contract call for save
+	*
+	* Generic implementation using wrapperKey and crudContract.
+	* Objects that don't support save leave wrapperKey/crudContract undefined.
+	*
+	* For 'create' mode: POSTs skeleton data (minimal fields).
+	* For 'update' mode: PUTs full data (all fields except abapLanguageVersion).
+	*
+	* @param mode - 'create' (POST skeleton) or 'update' (PUT full)
+	* @param options - Contract options (transport, lockHandle)
+	*/
+	async saveViaContract(mode, options) {
+		const wrapperKey = this.wrapperKey;
+		const contract = this.crudContract;
+		if (!wrapperKey || !contract) throw new Error(`Save not supported for ${this.kind}.`);
+		if (mode === "create") {
+			const skeleton = await this.getSkeletonData();
+			const data = { [wrapperKey]: skeleton };
+			await contract.post({ corrNr: options.transport }, data);
+		} else {
+			const { abapLanguageVersion: _, ...rest } = await this.data();
+			const saveData = rest;
+			const data = { [wrapperKey]: saveData };
+			if (contract.get) try {
+				await contract.get(this.name);
+			} catch {
+				this.ctx.client.clearETag();
+			}
+			await contract.put(this.name, {
+				corrNr: options.transport,
+				lockHandle: options.lockHandle
+			}, data);
+		}
+	}
+	/**
+	* Get skeleton data for object creation (POST).
+	*
+	* Returns only the minimal fields needed to create the object on SAP.
+	* SAP creates the object structure (includes, etc.) from these fields.
+	* Full metadata and source code are sent via PUT in the update step.
+	*
+	* Override in subclasses that need different skeleton fields.
+	*/
+	async getSkeletonData() {
+		const d = await this.data();
+		return {
+			name: d.name,
+			type: d.type,
+			description: d.description ?? "",
+			language: d.language ?? "EN",
+			masterLanguage: d.masterLanguage ?? "EN",
+			packageRef: d.packageRef
+		};
+	}
+	/**
+	* Check if the object exists on the SAP system.
+	*
+	* Used by upsert mode to decide between update and create paths upfront.
+	* On BTP, locking a non-existent DDIC object creates a draft that persists
+	* even after unlock, blocking subsequent POST (create) attempts. Checking
+	* existence first with GET avoids this problem entirely.
+	*/
+	async checkObjectExists() {
+		const contract = this.crudContract;
+		if (!contract?.get) return true;
+		try {
+			await contract.get(this.name);
+			return true;
+		} catch (e) {
+			if (this.shouldFallbackToCreate(e)) return false;
+			throw e;
+		}
+	}
+	/**
+	* Check if error is a 404 Not Found
+	*/
+	isNotFoundError(e) {
+		if (e instanceof Error) return e.message.includes("404") || e.message.includes("Not Found");
+		return false;
+	}
+	/**
+	* Upsert fallback: try POST (create), treat 422 "already exists" as unchanged.
+	* Extracted to avoid duplication in lock-catch and saveViaContract-catch paths.
+	*/
+	async fallbackToCreate(options) {
+		try {
+			return await this.save({
+				...options,
+				mode: "create"
+			});
+		} catch (createErr) {
+			if (this.isAlreadyExistsError(createErr)) {
+				this._unchanged = true;
+				return this;
+			}
+			throw createErr;
+		}
+	}
+	/**
+	* Check if error suggests the object doesn't exist or the operation
+	* is not supported for the current state.
+	*
+	* Some SAP DDIC endpoints (TABL, TTYP) return 405 Method Not Allowed
+	* instead of 404 when attempting to lock or PUT a non-existent object.
+	* In upsert mode, both should trigger a fallback to POST (create).
+	*/
+	shouldFallbackToCreate(e) {
+		if (this.isNotFoundError(e)) return true;
+		if (e instanceof Error) {
+			const msg = e.message;
+			if (msg.includes("405") || msg.includes("Method Not Allowed")) return true;
+			if (msg.includes("403") && msg.includes("S_ABPLNGVS")) return true;
+		}
+		return false;
+	}
+	/**
+	* Check if error is a 422 "already exists" from a POST create attempt
+	*/
+	isAlreadyExistsError(e) {
+		const msg = e instanceof Error ? e.message.toLowerCase() : "";
+		return (msg.includes("422") || msg.includes("unprocessable")) && msg.includes("already exists");
+	}
+	/**
+	* Check if object has pending sources to save
+	* Subclasses with source code (classes, interfaces) override this
+	*/
+	hasPendingSources() {
+		const self = this;
+		return !!(self._pendingSources || self._pendingSource);
+	}
+	/**
+	* Normalize source code for comparison.
+	* Trims trailing whitespace/newlines so minor formatting differences
+	* don't trigger unnecessary saves.
+	*/
+	normalizeSource(source) {
+		return source.split("\n").map((line) => line.trimEnd()).join("\n").trimEnd();
+	}
+	/**
+	* Check if pending sources are unchanged vs SAP (pre-lock comparison).
+	* Sets _unchanged = true if nothing needs saving.
+	*
+	* Default handles single-source objects (_pendingSource) by fetching
+	* GET {objectUri}/source/main and comparing.
+	* AdkClass overrides this for multi-include logic.
+	*/
+	async checkPendingSourcesUnchanged() {
+		const self = this;
+		if (!self._pendingSource) return;
+		try {
+			const currentSource = await toText(await this.ctx.client.fetch(`${this.objectUri}/source/main`, {
+				method: "GET",
+				headers: { Accept: "text/plain" }
+			}));
+			if (this.normalizeSource(currentSource) === this.normalizeSource(self._pendingSource)) {
+				this._unchanged = true;
+				delete self._pendingSource;
+			}
+		} catch {}
+	}
+	/**
+	* Check if metadata-only objects are unchanged on SAP.
+	*
+	* For objects without source code (DDIC types like DOMA, DTEL, TABL, TTYP),
+	* fetches the current SAP state and compares only the fields present in
+	* the local data. SAP returns extra volatile fields (timestamps, links,
+	* version, etc.) that are ignored — only semantic fields matter.
+	*/
+	async checkMetadataUnchanged() {
+		const contract = this.crudContract;
+		const wrapperKey = this.wrapperKey;
+		if (!contract?.get || !wrapperKey) return;
+		try {
+			const sapData = (await contract.get(this.name))?.[wrapperKey];
+			if (!sapData) return;
+			const localData = await this.data();
+			const isEmpty = (v) => v == null || v === "" || Array.isArray(v) && v.length === 0 || typeof v === "object" && v !== null && Object.keys(v).length === 0;
+			const isSubsetMatch = (local, sap) => {
+				if (local === sap) return true;
+				if (isEmpty(local) && isEmpty(sap)) return true;
+				if (isEmpty(local) && sap != null) return true;
+				if (local == null || sap == null) return false;
+				if (typeof local !== typeof sap) return false;
+				if (Array.isArray(local)) {
+					if (!Array.isArray(sap)) return false;
+					if (local.length !== sap.length) return false;
+					return local.every((item, i) => isSubsetMatch(item, sap[i]));
+				}
+				if (typeof local === "object") {
+					const localObj = local;
+					const sapObj = sap;
+					return Object.keys(localObj).every((key) => {
+						if (key === "abapLanguageVersion") return true;
+						return isSubsetMatch(localObj[key], sapObj[key]);
+					});
+				}
+				return local === sap;
+			};
+			if (isSubsetMatch(localData, sapData)) this._unchanged = true;
+		} catch {}
+	}
+	/**
+	* Refresh cached ETags after acquiring a lock.
+	*
+	* SAP changes the object's internal version when a lock is acquired,
+	* which invalidates any cached ETags. Without refreshing, the next
+	* PUT sends a stale If-Match header and SAP returns HTTP 412.
+	*
+	* For objects with pending sources: re-GET {objectUri}/source/main
+	* For metadata-only objects: re-GET via crudContract.get()
+	*
+	* Subclasses with multiple source endpoints (e.g., AdkClass with includes)
+	* should override this to refresh all relevant endpoints.
+	*/
+	async refreshETagsAfterLock() {
+		if (this.hasPendingSources()) {
+			const sourceUrl = `${this.objectUri}/source/main`;
+			try {
+				await this.ctx.client.fetch(sourceUrl, {
+					method: "GET",
+					headers: { Accept: "text/plain" }
+				});
+			} catch {
+				this.ctx.client.clearETag(sourceUrl);
+			}
+		} else {
+			const contract = this.crudContract;
+			if (contract?.get) try {
+				await contract.get(this.name);
+			} catch {
+				this.ctx.client.clearETag();
+			}
+		}
+	}
+	/**
+	* Save pending sources to SAP.
+	*
+	* Default handles single-source objects (_pendingSource) by PUTting
+	* to {objectUri}/source/main.
+	* AdkClass overrides this for multi-include logic.
+	*/
+	async savePendingSources(options) {
+		const self = this;
+		if (!self._pendingSource) return;
+		const sourceUrl = `${this.objectUri}/source/main`;
+		try {
+			await this.ctx.client.fetch(sourceUrl, {
+				method: "GET",
+				headers: { Accept: "text/plain" }
+			});
+		} catch {
+			this.ctx.client.clearETag(sourceUrl);
+		}
+		const params = new URLSearchParams();
+		if (options?.lockHandle) params.set("lockHandle", options.lockHandle);
+		if (options?.transport) params.set("corrNr", options.transport);
+		const qs = params.toString();
+		await this.ctx.client.fetch(`${sourceUrl}${qs ? "?" + qs : ""}`, {
+			method: "PUT",
+			headers: { "Content-Type": "text/plain" },
+			body: self._pendingSource
+		});
+		delete self._pendingSource;
+	}
+	/**
+	* Set source content for a source-based object
+	*
+	* Generic implementation for objects with source code (classes, includes, etc.)
+	* Subclasses should override if they need custom source handling.
+	*
+	* @param sourcePath - Relative path to source (e.g., '/source/main')
+	* @param content - Source code content
+	* @param options - Save options
+	*/
+	async setSource(sourcePath, content, options = {}) {
+		const { transport } = options;
+		const wasLocked = this.isLocked;
+		if (!wasLocked) await this.lock();
+		try {
+			const params = new URLSearchParams();
+			if (transport) params.set("corrNr", transport);
+			if (this._lockHandle) params.set("lockHandle", this._lockHandle.handle);
+			const fullPath = `${this.objectUri}${sourcePath}`;
+			const url = params.toString() ? `${fullPath}?${params.toString()}` : fullPath;
+			await this.ctx.client.fetch(url, {
+				method: "PUT",
+				headers: { "Content-Type": "text/plain; charset=utf-8" },
+				body: content
+			});
+		} finally {
+			if (!wasLocked) await this.unlock();
+		}
+	}
+	/**
+	* Activate this object
+	*
+	* Activates a single object. For bulk activation of multiple objects,
+	* use `AdkObjectSet.activateAll()`.
+	*
+	* @returns this (for chaining)
+	*/
+	async activate() {
+		const activationXml = `<?xml version="1.0" encoding="UTF-8"?>
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:uri="${this.objectUri}" adtcore:type="${this.type}" adtcore:name="${this.name}"/>
+</adtcore:objectReferences>`;
+		await this.ctx.client.fetch("/sap/bc/adt/activation?method=activate&preauditRequested=true", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/xml",
+				Accept: "application/xml"
+			},
+			body: activationXml
+		});
+		return this;
+	}
+	/** Lazy load a segment (async) - fetches only once, then cached */
+	async lazy(key, loader) {
+		if (!this.cache.has(key)) this.cache.set(key, await loader());
+		return this.cache.get(key);
+	}
+	/** Lazy compute a segment (sync) - computes only once, then cached */
+	cached(key, compute) {
+		if (!this.cache.has(key)) this.cache.set(key, compute());
+		return this.cache.get(key);
+	}
+	/** Set a cached value directly (for local/generated data) */
+	set(key, value) {
+		this.cache.set(key, value);
+	}
+	/** Mark a segment as dirty (modified locally) */
+	markDirty(key) {
+		this.dirty.add(key);
+	}
+	/** Check if any segment (or specific segment) is dirty */
+	isDirty(segment) {
+		return segment ? this.dirty.has(segment) : this.dirty.size > 0;
+	}
+	/** Clear cache for a segment (force reload on next access) */
+	invalidate(key) {
+		this.cache.delete(key);
+		this.dirty.delete(key);
+	}
+	/**
+	* Fetch a text resource from an ADT endpoint.
+	* Delegates to the underlying ADT client's fetch.
+	*
+	* @param url - ADT endpoint path (e.g., '/sap/bc/adt/ddic/dataelements/spras')
+	* @param headers - Optional HTTP headers (defaults to no Accept header, letting server choose)
+	* @returns Response content as text, or undefined if 404
+	*/
+	async fetchText(url, headers) {
+		try {
+			return toText(await this.ctx.client.fetch(url, {
+				method: "GET",
+				headers: headers ?? {}
+			}));
+		} catch {
+			return;
+		}
+	}
+};
+/**
+* Base class for main development objects (AdtMainObject)
+*
+* Extends AdkObject with package reference, responsible user, and master language.
+* Used for repository objects like classes, interfaces, packages, etc.
+*
+* Note: Uses type assertions internally because schema-inferred types from
+* contracts may have different shapes than AdkMainObjectData. The getters
+* safely handle missing properties with defaults.
+*
+* @typeParam K - The object kind (from AdkKind)
+* @typeParam D - The internal data type (typically schema-inferred from contract)
+*/
+var AdkMainObject = class extends AdkObject {
+	get mainData() {
+		return this.dataSync;
+	}
+	/** Package reference (adtcore:packageRef) */
+	get packageRef() {
+		return this.mainData.packageRef;
+	}
+	/** Package name (convenience getter) */
+	get package() {
+		return this.mainData.packageRef?.name ?? "";
+	}
+	/** Master system (adtcore:masterSystem) */
+	get masterSystem() {
+		return this.mainData.masterSystem ?? "";
+	}
+	/** Master language (adtcore:masterLanguage) */
+	get masterLanguage() {
+		return this.mainData.masterLanguage ?? "";
+	}
+	/** Responsible user (adtcore:responsible) */
+	get responsible() {
+		return this.mainData.responsible ?? "";
+	}
+	/** ABAP language version (adtcore:abapLanguageVersion) */
+	get abapLanguageVersion() {
+		return this.mainData.abapLanguageVersion ?? "";
+	}
+	/**
+	* Save main source code to SAP.
+	* Requires the object to be locked before calling.
+	* Subclasses may override to add additional behavior (e.g. cache invalidation).
+	*/
+	async saveMainSource(source, options) {
+		const params = new URLSearchParams();
+		if (options?.lockHandle) params.set("lockHandle", options.lockHandle);
+		if (options?.transport) params.set("corrNr", options.transport);
+		const qs = params.toString();
+		await this.ctx.client.fetch(`${this.objectUri}/source/main${qs ? "?" + qs : ""}`, {
+			method: "PUT",
+			headers: { "Content-Type": "text/plain" },
+			body: source
+		});
+	}
+};
+
+//#endregion
+//#region src/base/object-set.ts
+/**
+* ADK Object Set - Collection of objects with bulk operations
+*
+* A semantic layer for managing collections of ADK objects and
+* performing bulk operations like save and activate.
+*/
+var AdkObjectSet = class AdkObjectSet {
+	ctx;
+	objects = [];
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/**
+	* Add a single object to the set
+	*
+	* Propagates the set's context (lockService, lockStore) to the object
+	* so that objects created by plugins with a bare { client } context
+	* inherit the services configured on the set.
+	*/
+	add(object) {
+		if (!this.objects.includes(object)) {
+			object.adoptContext(this.ctx);
+			this.objects.push(object);
+		}
+		return this;
+	}
+	/**
+	* Add multiple objects to the set
+	*/
+	addAll(objects) {
+		for (const obj of objects) this.add(obj);
+		return this;
+	}
+	/**
+	* Remove an object from the set
+	*/
+	remove(object) {
+		const index = this.objects.indexOf(object);
+		if (index !== -1) this.objects.splice(index, 1);
+		return this;
+	}
+	/**
+	* Clear all objects from the set
+	*/
+	clear() {
+		this.objects.length = 0;
+		return this;
+	}
+	/**
+	* Get all objects in the set
+	*/
+	getAll() {
+		return [...this.objects];
+	}
+	/**
+	* Get number of objects in the set
+	*/
+	get size() {
+		return this.objects.length;
+	}
+	/**
+	* Check if set is empty
+	*/
+	get isEmpty() {
+		return this.objects.length === 0;
+	}
+	/**
+	* Filter objects by type
+	*/
+	filterByType(type) {
+		return this.objects.filter((obj) => obj.type === type);
+	}
+	/**
+	* Filter objects by kind
+	*/
+	filterByKind(kind) {
+		return this.objects.filter((obj) => obj.kind === kind);
+	}
+	/**
+	* Iterate over objects
+	*/
+	[Symbol.iterator]() {
+		return this.objects[Symbol.iterator]();
+	}
+	/**
+	* Save all objects in the set
+	*
+	* Saves each object individually, handling lock/unlock per object.
+	* By default continues on error to save as many objects as possible.
+	*
+	* @param options - Save options (transport, inactive, continueOnError)
+	* @returns Result with success/failure counts and details
+	*/
+	async saveAll(options = {}) {
+		const { continueOnError = true, onProgress, ...saveOptions } = options;
+		const result = {
+			success: 0,
+			failed: 0,
+			unchanged: 0,
+			results: []
+		};
+		const total = this.objects.length;
+		let _saved = 0;
+		let processed = 0;
+		for (const obj of this.objects) {
+			try {
+				await obj.save(saveOptions);
+				if (obj._unchanged) {
+					result.unchanged++;
+					result.results.push({
+						object: obj,
+						success: true,
+						unchanged: true
+					});
+				} else {
+					_saved++;
+					result.success++;
+					result.results.push({
+						object: obj,
+						success: true
+					});
+				}
+			} catch (error) {
+				result.failed++;
+				result.results.push({
+					object: obj,
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				if (!continueOnError) {
+					processed++;
+					onProgress?.(processed, total, obj);
+					break;
+				}
+			}
+			processed++;
+			onProgress?.(processed, total, obj);
+		}
+		return result;
+	}
+	/**
+	* Activate all objects in the set (bulk activation)
+	*
+	* Uses SAP's bulk activation endpoint for efficiency.
+	* All objects are activated in a single request.
+	*
+	* @param options - Activation options
+	* @returns Activation result with success/failure counts
+	*/
+	async activateAll(options = {}) {
+		const { onProgress } = options;
+		if (this.objects.length === 0) return {
+			success: 0,
+			failed: 0,
+			messages: []
+		};
+		onProgress?.(`Activating ${this.objects.length} objects...`);
+		const activationXml = `<?xml version="1.0" encoding="UTF-8"?>
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  ${this.objects.map((obj) => `<adtcore:objectReference adtcore:uri="${obj.objectUri}" adtcore:type="${obj.type}" adtcore:name="${obj.name}"/>`).join("\n  ")}
+</adtcore:objectReferences>`;
+		try {
+			const response = await this.ctx.client.fetch("/sap/bc/adt/activation?method=activate&preauditRequested=true", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/xml",
+					Accept: "application/xml"
+				},
+				body: activationXml
+			});
+			return {
+				success: this.objects.length,
+				failed: 0,
+				messages: [],
+				response: String(response)
+			};
+		} catch (error) {
+			return {
+				success: 0,
+				failed: this.objects.length,
+				messages: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	/**
+	* Save all objects as inactive, then bulk activate, then unlock
+	*
+	* This is the recommended pattern for deploying multiple objects:
+	* 1. Save all objects as inactive (handles dependencies)
+	* 2. Bulk activate all saved objects
+	* 3. Unlock all objects
+	*
+	* @param options - Save options (transport required)
+	* @returns Combined result of save and activation
+	*/
+	async deploy(options) {
+		const { activate = true, ...saveOptions } = options;
+		try {
+			const saveResult = await this.saveAll({
+				...saveOptions,
+				inactive: true
+			});
+			let activationResult;
+			if (activate && saveResult.success > 0) {
+				const savedSet = new AdkObjectSet(this.ctx);
+				for (const r of saveResult.results) if (r.success) savedSet.add(r.object);
+				activationResult = await savedSet.activateAll();
+				for (const r of saveResult.results) {
+					if (!r.success) continue;
+					const obj = r.object;
+					const deferred = obj._deferredSources;
+					if (deferred && deferred.length > 0) try {
+						const lock = await r.object.lock();
+						for (const [key, source] of deferred) await obj.saveIncludeSource(key, source, {
+							lockHandle: lock.handle,
+							transport: saveOptions.transport
+						});
+						delete obj._deferredSources;
+						const deferredSet = new AdkObjectSet(this.ctx);
+						deferredSet.add(r.object);
+						await deferredSet.activateAll();
+					} catch {} finally {
+						try {
+							await r.object.unlock();
+						} catch {}
+					}
+				}
+			}
+			return {
+				save: saveResult,
+				activation: activationResult
+			};
+		} finally {
+			await this.unlockAll();
+		}
+	}
+	/**
+	* Lock all objects in the set
+	*
+	* @returns Array of lock handles
+	*/
+	async lockAll() {
+		const handles = [];
+		for (const obj of this.objects) {
+			const handle = await obj.lock();
+			handles.push(handle);
+		}
+		return handles;
+	}
+	/**
+	* Unlock all objects in the set
+	*/
+	async unlockAll() {
+		for (const obj of this.objects) try {
+			await obj.unlock();
+		} catch {}
+	}
+	/**
+	* Load all objects (fetch data from SAP)
+	*
+	* @param options - Load options
+	* @returns This set (for chaining)
+	*/
+	async loadAll(options = {}) {
+		const { parallel = false } = options;
+		if (parallel) await Promise.all(this.objects.map((obj) => obj.load()));
+		else for (const obj of this.objects) await obj.load();
+		return this;
+	}
+	/**
+	* Create an object set from an array of objects
+	*/
+	static from(objects, ctx) {
+		const set = new AdkObjectSet(ctx);
+		set.addAll(objects);
+		return set;
+	}
+	/**
+	* Create an object set by collecting from an async generator
+	*
+	* Collects all objects yielded by the generator into the set.
+	* Useful for collecting objects from format plugin export generators.
+	*
+	* @param generator - Async generator yielding AdkObject instances
+	* @param ctx - ADK context for the set
+	* @param options - Collection options
+	* @returns Promise resolving to populated AdkObjectSet
+	*/
+	static async fromGenerator(generator, ctx, options = {}) {
+		const { filter, onObject } = options;
+		const set = new AdkObjectSet(ctx);
+		for await (const obj of generator) {
+			if (filter && !filter(obj)) continue;
+			set.add(obj);
+			onObject?.(obj);
+		}
+		return set;
+	}
+};
+
+//#endregion
+//#region src/base/adt.ts
+/**
+* Create ADK contract from ADT client
+*
+* @param client - ADT client instance from createAdtClient()
+* @returns ADK contract proxy
+*/
+function createAdkContract(client) {
+	return {
+		oo: client.adt.oo,
+		packages: client.adt.packages,
+		cts: client.adt.cts,
+		core: client.adt.core,
+		repository: client.adt.repository,
+		programs: client.adt.programs,
+		functions: client.adt.functions,
+		ddic: client.adt.ddic,
+		bo: client.adt.bo
+	};
+}
+
+//#endregion
+//#region src/base/global-context.ts
+let globalContext = null;
+/**
+* Initialize the global ADK context from an ADT client.
+*
+* Call this once during application bootstrap (e.g., in CLI initialization).
+* After initialization, ADK objects can be used without passing context.
+*
+* @param client - ADT client v2 instance
+* @throws Error if client is not provided
+*
+* @example
+* ```ts
+* import { initializeAdk } from '@abapify/adk';
+* import { createAdtClient } from '@abapify/adt-client';
+*
+* const client = createAdtClient({ ... });
+* initializeAdk(client);
+*
+* // Now ADK objects work without context
+* const transport = await AdkTransportRequest.get('S0DK900001');
+* ```
+*/
+function initializeAdk(client, options) {
+	if (!client) throw new Error("ADK initialization failed: client is required");
+	const lockStore = options?.lockStore;
+	globalContext = {
+		client,
+		lockStore,
+		lockService: options?.lockService ?? createLockService$1(client, { store: lockStore })
+	};
+}
+/**
+* Get the global ADK context.
+*
+* Used internally by ADK objects when no explicit context is provided.
+*
+* @returns The global ADK context
+* @throws Error if ADK has not been initialized
+*
+* @example
+* ```ts
+* // Internal usage in ADK objects:
+* static async get(number: string, ctx?: AdkContext): Promise<AdkTransportRequest> {
+*   const context = ctx ?? getGlobalContext();
+*   // ...
+* }
+* ```
+*/
+function getGlobalContext() {
+	if (!globalContext) throw new Error("ADK not initialized. Call initializeAdk(client) before using ADK objects.\nExample:\n  import { initializeAdk } from '@abapify/adk';\n  initializeAdk(client);");
+	return globalContext;
+}
+/**
+* Check if ADK has been initialized.
+*
+* Useful for conditional logic or error handling.
+*
+* @returns true if initializeAdk() has been called
+*/
+function isAdkInitialized() {
+	return globalContext !== null;
+}
+/**
+* Reset the global ADK context.
+*
+* Primarily for testing purposes. Clears the global context.
+*/
+function resetAdk() {
+	globalContext = null;
+}
+/**
+* Get the global context or return undefined if not initialized.
+*
+* Unlike getGlobalContext(), this doesn't throw - useful when you want
+* to check if context exists before using it.
+*
+* @returns The global context or undefined
+*/
+function tryGetGlobalContext() {
+	return globalContext ?? void 0;
+}
+
+//#endregion
+//#region src/objects/repository/devc/devc.model.ts
+/**
+* DEVC - ABAP Package
+*
+* ADK object for ABAP packages (DEVC).
+*/
+/**
+* ADK Package object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+* - AdkMainObject: packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Note: For packages, the parent package is stored in `superPackage` not `packageRef`.
+* The `package` getter is overridden to return the super package name.
+*/
+var AdkPackage = class AdkPackage extends AdkMainObject {
+	static kind = Package;
+	kind = AdkPackage.kind;
+	get objectUri() {
+		return `/sap/bc/adt/packages/${encodeURIComponent(this.name)}`;
+	}
+	get package() {
+		return this.dataSync.superPackage?.name ?? "";
+	}
+	get attributes() {
+		const attrs = this.dataSync.attributes;
+		return {
+			packageType: attrs?.packageType ?? "development",
+			isEncapsulated: attrs?.isEncapsulated ?? false,
+			isAddingObjectsAllowed: attrs?.isAddingObjectsAllowed ?? true,
+			recordChanges: attrs?.recordChanges ?? false,
+			languageVersion: attrs?.languageVersion ?? ""
+		};
+	}
+	get superPackage() {
+		const sp = this.dataSync.superPackage;
+		if (!sp?.name) return void 0;
+		return {
+			uri: sp.uri ?? "",
+			type: sp.type ?? "DEVC/K",
+			name: sp.name,
+			description: sp.description
+		};
+	}
+	get applicationComponent() {
+		const ac = this.dataSync.applicationComponent;
+		if (!ac?.name) return void 0;
+		return {
+			name: ac.name,
+			description: ac.description ?? ""
+		};
+	}
+	get transport() {
+		const t = this.dataSync.transport;
+		if (!t) return void 0;
+		return {
+			softwareComponent: t.softwareComponent?.name ? {
+				name: t.softwareComponent.name,
+				description: t.softwareComponent.description ?? ""
+			} : void 0,
+			transportLayer: t.transportLayer?.name ? {
+				name: t.transportLayer.name,
+				description: t.transportLayer.description ?? ""
+			} : void 0
+		};
+	}
+	async getSubpackages() {
+		return this.lazy("subpackages", async () => {
+			const response = await this.ctx.client.adt.repository.informationsystem.search.quickSearch({
+				query: "*",
+				packageName: this.name,
+				objectType: "DEVC",
+				maxResults: 1e3
+			});
+			const refs = "objectReferences" in response ? response.objectReferences?.objectReference ?? [] : [];
+			const subpkgRefs = (Array.isArray(refs) ? refs : [refs]).filter((ref) => !!ref.name && ref.type === "DEVC/K" && ref.name !== this.name);
+			return (await Promise.all(subpkgRefs.map(async (ref) => {
+				const pkg = new AdkPackage(this.ctx, ref.name);
+				await pkg.load();
+				return pkg;
+			}))).filter((pkg) => pkg.superPackage?.name?.toUpperCase() === this.name.toUpperCase());
+		});
+	}
+	async getObjects() {
+		return this.lazy("objects", async () => {
+			const response = await this.ctx.client.adt.repository.informationsystem.search.quickSearch({
+				query: "*",
+				packageName: this.name,
+				maxResults: 1e3
+			});
+			const refs = "objectReferences" in response ? response.objectReferences?.objectReference ?? [] : [];
+			return (Array.isArray(refs) ? refs : [refs]).filter((ref) => !!ref.name && ref.type !== "DEVC/K" && ref.packageName?.toUpperCase() === this.name.toUpperCase()).map((ref) => ({
+				kind: ref.type ?? "",
+				type: ref.type ?? "",
+				name: ref.name,
+				description: ref.description ?? "",
+				package: ref.packageName ?? ""
+			}));
+		});
+	}
+	async getAllObjects() {
+		return this.lazy("allObjects", async () => {
+			const direct = await this.getObjects();
+			const subpackages = await this.getSubpackages();
+			const nested = await Promise.all(subpackages.map((pkg) => pkg.getAllObjects()));
+			const seen = /* @__PURE__ */ new Set();
+			return [...direct, ...nested.flat()].filter((obj) => {
+				const key = `${obj.type}:${obj.name}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		});
+	}
+	async load() {
+		const response = await this.ctx.client.adt.packages.get(this.name);
+		if (!response || !("package" in response) || !response.package) throw new Error(`Package '${this.name}' not found or returned empty response`);
+		this.setData(response.package);
+		return this;
+	}
+	get wrapperKey() {
+		return "package";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.packages;
+	}
+	/**
+	* Get skeleton data for package creation (POST).
+	*
+	* SAP requires ALL elements in the Package xs:sequence, even if empty.
+	* The sequence order is: attributes, superPackage, extensionAlias, switch,
+	* applicationComponent, transport, translation, useAccesses,
+	* packageInterfaces, subPackages.
+	* Missing elements cause "System expected the element ..." 400 errors.
+	*/
+	async getSkeletonData() {
+		const d = await this.data();
+		return {
+			name: d.name,
+			type: d.type ?? "DEVC/K",
+			description: d.description ?? "",
+			language: d.language ?? "EN",
+			masterLanguage: d.masterLanguage ?? "EN",
+			responsible: d.responsible ?? "",
+			attributes: d.attributes ?? { packageType: "development" },
+			superPackage: d.superPackage ?? {},
+			extensionAlias: d.extensionAlias ?? {},
+			switch: d.switch ?? {},
+			applicationComponent: d.applicationComponent ?? {},
+			transport: d.transport ?? {},
+			translation: d.translation ?? {},
+			useAccesses: d.useAccesses ?? {},
+			packageInterfaces: d.packageInterfaces ?? {},
+			subPackages: d.subPackages ?? {}
+		};
+	}
+	/**
+	* Get a package by name
+	*
+	* @param name - Package name (e.g., '$TMP', 'ZPACKAGE')
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async get(name, ctx) {
+		const pkg = new AdkPackage(ctx ?? getGlobalContext(), name);
+		await pkg.load();
+		return pkg;
+	}
+	/**
+	* Check if a package exists on SAP
+	*
+	* @param name - Package name
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	* @returns true if package exists, false otherwise
+	*/
+	static async exists(name, ctx) {
+		try {
+			await new AdkPackage(ctx ?? getGlobalContext(), name).load();
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new package on SAP
+	*
+	* Builds an AdkPackage with the given data and saves it in 'create' mode.
+	*
+	* @param name - Package name (e.g., 'ZABAPGIT_EXAMPLES_CLAS')
+	* @param data - Package data (superPackage, attributes, transport, etc.)
+	* @param options - Save options (transport request)
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async create(name, data, options, ctx) {
+		const pkg = new AdkPackage(ctx ?? getGlobalContext(), name);
+		pkg.setData({
+			name,
+			type: "DEVC/K",
+			description: data.description ?? name,
+			responsible: data.responsible ?? "",
+			attributes: {
+				packageType: "development",
+				...data.attributes
+			},
+			superPackage: data.superPackage ?? {},
+			extensionAlias: data.extensionAlias ?? {},
+			switch: data.switch ?? {},
+			applicationComponent: data.applicationComponent ?? {},
+			transport: data.transport ?? {},
+			translation: data.translation ?? {},
+			useAccesses: data.useAccesses ?? {},
+			packageInterfaces: data.packageInterfaces ?? {},
+			subPackages: data.subPackages ?? {},
+			...data
+		});
+		await pkg.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return pkg;
+	}
+	/**
+	* Delete an ABAP package from SAP
+	*
+	* @param name - Package name
+	* @param options - Delete options (transport, lockHandle)
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkPackage(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			...options?.transport && { corrNr: options.transport },
+			...options?.lockHandle && { lockHandle: options.lockHandle }
+		});
+	}
+};
+registerObjectType("DEVC", Package, AdkPackage, {
+	endpoint: "packages",
+	nameTransform: "preserve"
+});
+
+//#endregion
+//#region src/decorators/lockable.ts
+/**
+* @requiresLock - Method decorator
+*
+* Automatically acquires lock before method execution
+* and releases it after (unless keep: true).
+*
+* @param options - Lock options
+* @param options.keep - If true, keep lock after method completes
+*
+* @example
+* ```typescript
+* @requiresLock()
+* async update(data: UpdateData): Promise<void> {
+*   // Lock is acquired before this runs
+*   // Lock is released after this completes
+* }
+*
+* @requiresLock({ keep: true })
+* async startTransaction(): Promise<void> {
+*   // Lock is acquired and KEPT for subsequent operations
+* }
+* ```
+*/
+function requiresLock(options) {
+	return function(_target, _propertyKey, descriptor) {
+		const originalMethod = descriptor.value;
+		descriptor.value = async function(...args) {
+			const wasLocked = this.isLocked;
+			try {
+				if (!wasLocked) await this.lock();
+				return await originalMethod.apply(this, args);
+			} finally {
+				if (!wasLocked && this.isLocked && !options?.keep) await this.unlock();
+			}
+		};
+		return descriptor;
+	};
+}
+
+//#endregion
+//#region src/decorators/datetime.ts
+/**
+* @datetime - SAP Timestamp Property Decorator
+*
+* Parses SAP timestamp formats into JavaScript Date objects.
+*
+* SAP Timestamp Formats:
+* - YYYYMMDDHHMMSS (14 chars) - e.g., "20231215143052"
+* - YYYYMMDD (8 chars) - date only
+*
+* Usage:
+*   class MyObject {
+*     @datetime() lastChangedAt?: Date;
+*     @datetime('lastchanged_timestamp') modifiedAt?: Date;
+*   }
+*/
+/**
+* Parse SAP timestamp string to Date
+* Supports: YYYYMMDDHHMMSS (14 chars) or YYYYMMDD (8 chars)
+*/
+function parseSapTimestamp(ts) {
+	if (!ts || typeof ts !== "string") return void 0;
+	const s = ts.trim();
+	if (s.length < 8) return void 0;
+	const year = s.slice(0, 4);
+	const month = s.slice(4, 6);
+	const day = s.slice(6, 8);
+	const hour = s.length >= 10 ? s.slice(8, 10) : "00";
+	const min = s.length >= 12 ? s.slice(10, 12) : "00";
+	const sec = s.length >= 14 ? s.slice(12, 14) : "00";
+	return /* @__PURE__ */ new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}Z`);
+}
+
+//#endregion
+//#region src/decorators/lazy.ts
+/**
+* @lazy - Lazy Initialization Decorator
+*
+* Computes a value once on first access, then caches it.
+*
+* Usage:
+*   class MyObject {
+*     @lazy(self => `${self.a}/${self.b}`)
+*     key!: string;
+*   }
+*
+* Note: Due to class field shadowing, use `declare` keyword:
+*   @lazy(self => compute())
+*   declare myProp: Type;
+*/
+const LAZY_CACHE = Symbol("lazy:cache");
+/**
+* Invalidate a specific lazy property (force recomputation on next access)
+*/
+function invalidateLazy(obj, propertyKey) {
+	obj[LAZY_CACHE]?.delete(propertyKey);
+}
+
+//#endregion
+//#region src/objects/repository/clas/clas.model.ts
+/**
+* CLAS - ABAP Class
+*
+* ADK object for ABAP classes (CLAS).
+*/
+/**
+* ADK Class object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+* - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Access class-specific properties via `data`:
+* - data.category, data.final, data.abstract, data.visibility
+* - data.sharedMemoryEnabled, data.modeled, data.fixPointArithmetic
+* - data.superClassRef, data.messageClassRef, data.include
+*/
+var AdkClass = class AdkClass extends AdkMainObject {
+	static kind = Class;
+	kind = AdkClass.kind;
+	get objectUri() {
+		return `/sap/bc/adt/oo/classes/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	async getMainSource() {
+		return this.lazy("source:main", async () => {
+			return this.crudContract.source.main.get(this.name);
+		});
+	}
+	async getIncludeSource(includeType) {
+		return this.lazy(`source:${includeType}`, async () => {
+			if (includeType === "main") return this.crudContract.source.main.get(this.name);
+			return this.crudContract.includes.get(this.name, includeType);
+		});
+	}
+	async getDefinitions() {
+		return this.getIncludeSource("definitions");
+	}
+	async getImplementations() {
+		return this.getIncludeSource("implementations");
+	}
+	async getTestClasses() {
+		return this.getIncludeSource("testclasses");
+	}
+	/**
+	* Save main source code
+	* Requires object to be locked first
+	*/
+	async saveMainSource(source, options) {
+		await this.crudContract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+		invalidateLazy(this, "source:main");
+	}
+	/**
+	* Save include source code
+	* Requires object to be locked first
+	*/
+	async saveIncludeSource(includeType, source, options) {
+		const putOptions = {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		};
+		if (includeType === "main") await this.crudContract.source.main.put(this.name, putOptions, source);
+		else await this.crudContract.includes.put(this.name, includeType, putOptions, source);
+		invalidateLazy(this, `source:${includeType}`);
+	}
+	/**
+	* Save all pending sources (set via _pendingSources)
+	* Used by export workflow after deserialization from abapGit
+	* Overrides base class method
+	*
+	* Note: unchanged detection is handled by checkPendingSourcesUnchanged()
+	* which runs BEFORE lock acquisition. By the time we reach here,
+	* at least one source differs — save them all.
+	*/
+	async savePendingSources(options) {
+		const pendingSources = this._pendingSources;
+		if (!pendingSources) return;
+		const errors = [];
+		const deferred = [];
+		for (const [key, source] of Object.entries(pendingSources)) try {
+			if (key === "main") await this.saveMainSource(source, options);
+			else await this.saveIncludeSource(key, source, options);
+		} catch (e) {
+			const errorMsg = e instanceof Error ? e.message : String(e);
+			if (errorMsg.includes("409") || errorMsg.includes("Conflict")) continue;
+			if (errorMsg.includes("does not have any inactive version") || errorMsg.includes("ResourceNotFound")) {
+				deferred.push([key, source]);
+				continue;
+			}
+			errors.push(e instanceof Error ? e : new Error(String(e)));
+		}
+		if (deferred.length > 0) this._deferredSources = deferred;
+		delete this._pendingSources;
+		delete this._pendingSource;
+		if (errors.length > 0) throw errors[0];
+	}
+	/**
+	* Pre-lock comparison: check if all pending sources match SAP
+	* If identical, sets _unchanged = true so save() skips locking and PUT
+	*/
+	async checkPendingSourcesUnchanged() {
+		const pendingSources = this._pendingSources;
+		if (!pendingSources) return;
+		for (const [key, pendingSource] of Object.entries(pendingSources)) try {
+			const currentSource = await this.getIncludeSource(key);
+			if (this.normalizeSource(currentSource) !== this.normalizeSource(pendingSource)) return;
+		} catch {
+			return;
+		}
+		this._unchanged = true;
+		delete this._pendingSources;
+		delete this._pendingSource;
+	}
+	/**
+	* Check if object has pending sources to save
+	* Overrides base class method
+	*/
+	hasPendingSources() {
+		return !!this._pendingSources;
+	}
+	/**
+	* Refresh cached ETags for all pending source endpoints after locking.
+	* Classes have multiple source URLs (main + includes) that all need fresh ETags.
+	*/
+	async refreshETagsAfterLock() {
+		const pendingSources = this._pendingSources;
+		if (!pendingSources) return super.refreshETagsAfterLock();
+		const basePath = `/sap/bc/adt/oo/classes/${this.name.toLowerCase()}`;
+		for (const key of Object.keys(pendingSources)) {
+			const endpoint = key === "main" ? `${basePath}/source/main` : `${basePath}/includes/${key}`;
+			try {
+				if (key === "main") await this.crudContract.source.main.get(this.name);
+				else await this.crudContract.includes.get(this.name, key);
+			} catch {
+				this.ctx.client.clearETag(endpoint);
+			}
+		}
+	}
+	get wrapperKey() {
+		return "abapClass";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.oo.classes;
+	}
+	static async get(name, ctx) {
+		return new AdkClass(ctx ?? getGlobalContext(), name).load();
+	}
+	/**
+	* Check if a class exists on SAP
+	*/
+	static async exists(name, ctx) {
+		try {
+			await AdkClass.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP class on SAP
+	*
+	* @param name - Class name (e.g., 'ZCL_MY_CLASS')
+	* @param description - Short description
+	* @param packageName - Package to assign the class to
+	* @param options - Save options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const cls = new AdkClass(ctx ?? getGlobalContext(), name.toUpperCase());
+		cls.setData({
+			name: name.toUpperCase(),
+			type: "CLAS/OC",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await cls.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return cls;
+	}
+	/**
+	* Delete an ABAP class from SAP
+	*
+	* @param name - Class name
+	* @param options - Delete options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkClass(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("CLAS", Class, AdkClass, { endpoint: "oo/classes" });
+
+//#endregion
+//#region src/objects/repository/intf/intf.model.ts
+/**
+* INTF - ABAP Interface
+*
+* ADK object for ABAP interfaces (INTF).
+*/
+/**
+* ADK Interface object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+* - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Access interface-specific properties via `data`:
+* - data.modeled, data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+*/
+var AdkInterface = class AdkInterface extends AdkMainObject {
+	static kind = Interface;
+	kind = AdkInterface.kind;
+	get objectUri() {
+		return `/sap/bc/adt/oo/interfaces/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.oo.interfaces.source.main.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "abapInterface";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.oo.interfaces;
+	}
+	static async get(name, ctx) {
+		return new AdkInterface(ctx ?? getGlobalContext(), name).load();
+	}
+	/**
+	* Check if an interface exists on SAP
+	*/
+	static async exists(name, ctx) {
+		try {
+			await AdkInterface.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP interface on SAP
+	*
+	* @param name - Interface name (e.g., 'ZIF_MY_INTERFACE')
+	* @param description - Short description
+	* @param packageName - Package to assign the interface to
+	* @param options - Save options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const intf = new AdkInterface(ctx ?? getGlobalContext(), name.toUpperCase());
+		intf.setData({
+			name: name.toUpperCase(),
+			type: "INTF/OI",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await intf.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return intf;
+	}
+	/**
+	* Delete an ABAP interface from SAP
+	*
+	* @param name - Interface name
+	* @param options - Delete options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkInterface(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("INTF", Interface, AdkInterface, { endpoint: "oo/interfaces" });
+
+//#endregion
+//#region src/objects/repository/prog/prog.model.ts
+/**
+* PROG - ABAP Program
+*
+* ADK object for ABAP programs (PROG).
+*/
+/**
+* ADK Program object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+* - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Access program-specific properties via `data`:
+* - data.programType, data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+*/
+var AdkProgram = class AdkProgram extends AdkMainObject {
+	static kind = Program;
+	kind = AdkProgram.kind;
+	get objectUri() {
+		return `/sap/bc/adt/programs/programs/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.programs.programs.source.main.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "abapProgram";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.programs.programs;
+	}
+	static async get(name, ctx) {
+		return new AdkProgram(ctx ?? getGlobalContext(), name).load();
+	}
+	/**
+	* Check if a program exists on SAP
+	*/
+	static async exists(name, ctx) {
+		try {
+			await AdkProgram.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP program on SAP
+	*
+	* @param name - Program name (e.g., 'ZMYPROGRAM')
+	* @param description - Short description
+	* @param packageName - Package to assign the program to
+	* @param options - Save options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const prog = new AdkProgram(ctx ?? getGlobalContext(), name.toUpperCase());
+		prog.setData({
+			name: name.toUpperCase(),
+			type: "PROG/P",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await prog.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return prog;
+	}
+	/**
+	* Delete an ABAP program from SAP
+	*
+	* @param name - Program name
+	* @param options - Delete options (transport)
+	* @param ctx - Optional ADK context
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkProgram(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("PROG", Program, AdkProgram, { endpoint: "programs/programs" });
+
+//#endregion
+//#region src/objects/repository/incl/incl.model.ts
+/**
+* INCL - ABAP Program Include
+*
+* ADK object for ABAP program includes (PROG/I). Mirrors the PROG model
+* but targets the `/sap/bc/adt/programs/includes` endpoint.
+*/
+/**
+* ADK Include object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At,
+*   createdBy/At, links
+* - AdkMainObject: package, packageRef, responsible, masterLanguage,
+*   masterSystem, abapLanguageVersion
+*
+* Access include-specific properties via `data`:
+* - data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck,
+*   data.contextRef (pointer to the main program)
+*/
+var AdkInclude = class AdkInclude extends AdkMainObject {
+	static kind = Include;
+	kind = AdkInclude.kind;
+	get objectUri() {
+		return `/sap/bc/adt/programs/includes/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.programs.includes.source.main.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "abapInclude";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.programs.includes;
+	}
+	/**
+	* Skeleton POST data for includes.
+	*
+	* Extends the base skeleton (name/type/description/packageRef) with
+	* `contextRef`, which sapcli's `sap.adt.Include(..., master=...)` serializes
+	* at creation time. Without this the include would be created detached
+	* from its main program.
+	*/
+	async getSkeletonData() {
+		const base = await super.getSkeletonData();
+		const d = await this.data();
+		if (d.contextRef) base.contextRef = d.contextRef;
+		return base;
+	}
+	static async get(name, ctx) {
+		return new AdkInclude(ctx ?? getGlobalContext(), name).load();
+	}
+	/**
+	* Check if an include exists on SAP
+	*/
+	static async exists(name, ctx) {
+		try {
+			await AdkInclude.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP include on SAP
+	*
+	* @param name - Include name (e.g., 'ZMY_INCLUDE')
+	* @param description - Short description
+	* @param packageName - Package to assign the include to
+	* @param options - Save options (transport, master program)
+	* @param ctx - Optional ADK context
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const incl = new AdkInclude(ctx ?? getGlobalContext(), name.toUpperCase());
+		const data = {
+			name: name.toUpperCase(),
+			type: "PROG/I",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		};
+		if (options?.master) {
+			const master = options.master.toUpperCase();
+			data.contextRef = {
+				name: master,
+				uri: `/sap/bc/adt/programs/programs/${encodeURIComponent(master.toLowerCase())}`,
+				type: "PROG/P"
+			};
+		}
+		incl.setData(data);
+		await incl.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return incl;
+	}
+	/**
+	* Delete an ABAP include from SAP
+	*
+	* @param name - Include name
+	* @param options - Delete options (transport, lockHandle)
+	* @param ctx - Optional ADK context
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkInclude(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("INCL", Include, AdkInclude, { endpoint: "programs/includes" });
+
+//#endregion
+//#region src/objects/repository/fugr/fugr.model.ts
+/**
+* FUGR - ABAP Function Group
+*
+* ADK object for ABAP function groups (FUGR).
+*/
+/**
+* ADK Function Group object
+*
+* Inherits from AdkMainObject which provides:
+* - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+* - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Access function group-specific properties via `data`:
+* - data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+*/
+var AdkFunctionGroup = class AdkFunctionGroup extends AdkMainObject {
+	static kind = FunctionGroup;
+	kind = AdkFunctionGroup.kind;
+	get objectUri() {
+		return `/sap/bc/adt/functions/groups/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.functions.groups.source.main.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "abapFunctionGroup";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.functions.groups;
+	}
+	static async get(name, ctx) {
+		return new AdkFunctionGroup(ctx ?? getGlobalContext(), name).load();
+	}
+	/**
+	* Check if a function group exists on SAP
+	*/
+	static async exists(name, ctx) {
+		try {
+			await AdkFunctionGroup.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP function group on SAP
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const fugr = new AdkFunctionGroup(ctx ?? getGlobalContext(), name.toUpperCase());
+		fugr.setData({
+			name: name.toUpperCase(),
+			type: "FUGR/F",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await fugr.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return fugr;
+	}
+	/**
+	* Delete an ABAP function group from SAP
+	*/
+	static async delete(name, options, ctx) {
+		await new AdkFunctionGroup(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("FUGR", FunctionGroup, AdkFunctionGroup, {
+	endpoint: "functions/groups",
+	normalizeName: (name) => name.toUpperCase().startsWith("SAPL") ? name.slice(4) : name
+});
+
+//#endregion
+//#region src/objects/repository/fugr/func/func.model.ts
+/**
+* FUGR/FF - ABAP Function Module
+*
+* ADK object for ABAP function modules (FUGR/FF).
+* Function modules are child objects of function groups - they are accessed
+* via the parent group's URL path and require the group name for all operations.
+*/
+/**
+* ADK Function Module object
+*
+* Function modules are child objects of function groups. Unlike main objects
+* (classes, interfaces, etc.), they don't have their own package reference.
+* All API operations require the parent group name in the URL path.
+*
+* Key differences from AdkMainObject:
+* - Requires `groupName` for URI construction and all CRUD operations
+* - Overrides lock/unlock/load/save to pass groupName to contract calls
+* - No packageRef (lives within parent function group's package)
+*/
+var AdkFunctionModule = class AdkFunctionModule extends AdkObject {
+	static kind = FunctionModule;
+	kind = AdkFunctionModule.kind;
+	/** Parent function group name */
+	groupName;
+	/**
+	* Constructor supports two calling patterns:
+	*
+	* 1. Direct (3-arg): `new AdkFunctionModule(ctx, groupName, nameOrData)`
+	*    Used by static factory method and when group name is known upfront.
+	*
+	* 2. Factory (2-arg): `new AdkFunctionModule(ctx, data)`
+	*    Used by ADK factory's `getWithData()`. The groupName is extracted from
+	*    `data._groupName` or `data.containerRef.name`.
+	*/
+	constructor(ctx, groupNameOrData, dataOrName) {
+		if (dataOrName !== void 0) {
+			super(ctx, dataOrName);
+			this.groupName = groupNameOrData;
+		} else if (typeof groupNameOrData === "string") {
+			super(ctx, groupNameOrData);
+			this.groupName = "";
+		} else {
+			const data = groupNameOrData;
+			super(ctx, groupNameOrData);
+			this.groupName = data._groupName ?? data.containerRef?.name ?? "";
+		}
+	}
+	get objectUri() {
+		return `/sap/bc/adt/functions/groups/${encodeURIComponent(this.groupName.toLowerCase())}/fmodules/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	get collectionUri() {
+		return `/sap/bc/adt/functions/groups/${encodeURIComponent(this.groupName.toLowerCase())}/fmodules`;
+	}
+	get wrapperKey() {
+		return "abapFunctionModule";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.functions.groups.fmodules;
+	}
+	/**
+	* Load function module data from SAP
+	*
+	* Overrides base to pass groupName as first arg to contract.get()
+	*/
+	async load() {
+		const contract = this.crudContract;
+		const wrapperKey = this.wrapperKey;
+		if (!contract || !wrapperKey) throw new Error(`Load not implemented for ${this.kind}. Override load() or provide crudContract/wrapperKey.`);
+		const response = await contract.get(this.groupName, this.name);
+		if (!response || !(wrapperKey in response)) throw new Error(`${this.kind} '${this.name}' in group '${this.groupName}' not found or returned empty response`);
+		this.setData(response[wrapperKey]);
+		return this;
+	}
+	/**
+	* Get skeleton data for FM creation (POST).
+	*
+	* FMs only need name, type, description, and processing attributes.
+	* No packageRef — FMs inherit the package from their parent FUGR.
+	*/
+	async getSkeletonData() {
+		const d = await this.data();
+		return {
+			name: d.name,
+			type: d.type,
+			description: d.description ?? "",
+			processingType: d.processingType,
+			basXMLEnabled: d.basXMLEnabled
+		};
+	}
+	/**
+	* Execute the typed contract call for save
+	*
+	* Overrides base to pass groupName to contract.put()/post()
+	*/
+	async saveViaContract(mode, options) {
+		const wrapperKey = this.wrapperKey;
+		const contract = this.crudContract;
+		if (!wrapperKey || !contract) throw new Error(`Save not supported for ${this.kind}.`);
+		if (mode === "create") {
+			const skeleton = await this.getSkeletonData();
+			const data = { [wrapperKey]: skeleton };
+			await contract.post(this.groupName, { corrNr: options.transport }, data);
+		} else {
+			const { abapLanguageVersion: _, ...rest } = await this.data();
+			const saveData = rest;
+			const data = { [wrapperKey]: saveData };
+			await contract.put(this.groupName, this.name, {
+				corrNr: options.transport,
+				lockHandle: options.lockHandle
+			}, data);
+		}
+	}
+	/**
+	* Check if the function module exists on the SAP system.
+	*
+	* Overrides base to pass groupName to contract.get()
+	*/
+	async checkObjectExists() {
+		const contract = this.crudContract;
+		if (!contract?.get) return true;
+		try {
+			await contract.get(this.groupName, this.name);
+			return true;
+		} catch (e) {
+			if (this.shouldFallbackToCreate(e)) return false;
+			throw e;
+		}
+	}
+	/**
+	* Refresh cached ETags after acquiring a lock.
+	*
+	* FM's savePendingSources() does a metadata PUT first (to apply processingType),
+	* then a source PUT. Both need fresh ETags after locking.
+	* The contract uses groupName + name (potentially UPPERCASE), so we must
+	* refresh via the contract to match the same cache key.
+	*/
+	async refreshETagsAfterLock() {
+		try {
+			await this.crudContract.get(this.groupName, this.name);
+		} catch {
+			this.ctx.client.clearETag();
+		}
+		try {
+			await this.crudContract.source.main.get(this.groupName, this.name);
+		} catch {
+			this.ctx.client.clearETag(`${this.objectUri}/source/main`);
+		}
+	}
+	/**
+	* Strip the parameter comment block from FM source code.
+	*
+	* abapGit serializes FM source with a "Local Interface" comment block
+	* that describes IMPORTING/EXPORTING/CHANGING/TABLES/EXCEPTIONS.
+	* SAP ADT rejects this block when saving source — it manages the
+	* interface metadata separately. Strip it before sending.
+	*
+	* Pattern:
+	* ```
+	* *"----------------------------------------------------------------------
+	* *"*"Local Interface:
+	* *"  IMPORTING ...
+	* *"----------------------------------------------------------------------
+	* ```
+	*/
+	stripParameterCommentBlock(source) {
+		const lines = source.split("\n");
+		const result = [];
+		let inBlock = false;
+		for (let i = 0; i < lines.length; i++) {
+			const trimmed = lines[i].trimEnd();
+			if (!inBlock && trimmed.startsWith("*\"") && trimmed.includes("---")) {
+				if (i + 1 < lines.length && lines[i + 1].trimEnd().startsWith("*\"")) {
+					inBlock = true;
+					continue;
+				}
+			}
+			if (inBlock) {
+				if (trimmed.startsWith("*\"") && trimmed.includes("---")) {
+					inBlock = false;
+					continue;
+				}
+				if (trimmed.startsWith("*\"")) continue;
+				inBlock = false;
+			}
+			result.push(lines[i]);
+		}
+		return result.join("\n");
+	}
+	/**
+	* Save pending source for function module.
+	*
+	* Overrides base to:
+	* 1. PUT metadata first (SAP ignores processingType and other attributes during POST)
+	* 2. Refresh source ETag (metadata PUT changes the object version)
+	* 3. Strip the parameter comment block that abapGit includes
+	* 4. Use the FM-specific source endpoint via groupName
+	*/
+	async savePendingSources(options) {
+		const self = this;
+		if (!self._pendingSource) return;
+		await this.saveViaContract("update", {
+			lockHandle: options?.lockHandle,
+			transport: options?.transport
+		});
+		await this.crudContract.source.main.get(this.groupName, this.name);
+		const cleanSource = this.stripParameterCommentBlock(self._pendingSource);
+		await this.crudContract.source.main.put(this.groupName, this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, cleanSource);
+		delete self._pendingSource;
+	}
+	/**
+	* Extract the body of a FUNCTION...ENDFUNCTION block.
+	*
+	* SAP reconstructs the FUNCTION header when returning source code:
+	*   Local:  `FUNCTION zage_fm.`                         (lowercase, period inline)
+	*   SAP:    `FUNCTION ZAGE_FM\n " template comment"\n.` (uppercase, period on own line)
+	*
+	* The body between the header and ENDFUNCTION is identical, so we compare
+	* only that part. The header ends at the first period that terminates the
+	* FUNCTION statement (either inline `FUNCTION name.` or on a separate line `.`).
+	*/
+	extractFunctionBody(source) {
+		const lines = source.split("\n");
+		let bodyStart = 0;
+		let bodyEnd = lines.length;
+		for (let i = 0; i < lines.length; i++) {
+			const trimmed = lines[i].trimEnd();
+			if (i === 0 && /^FUNCTION\s+\S+\.\s*$/i.test(trimmed)) {
+				bodyStart = i + 1;
+				break;
+			}
+			if (i > 0 && trimmed === ".") {
+				bodyStart = i + 1;
+				break;
+			}
+		}
+		for (let i = lines.length - 1; i >= bodyStart; i--) if (/^\s*ENDFUNCTION\.\s*$/i.test(lines[i].trimEnd())) {
+			bodyEnd = i;
+			break;
+		}
+		return lines.slice(bodyStart, bodyEnd).join("\n");
+	}
+	/**
+	* Pre-lock comparison for FM source.
+	*
+	* Overrides base to:
+	* 1. Strip parameter comment block from local source
+	* 2. Extract only the function body (between FUNCTION header and ENDFUNCTION)
+	*    from both local and SAP source, because SAP reconstructs the FUNCTION
+	*    header with uppercase name and template comments.
+	*/
+	async checkPendingSourcesUnchanged() {
+		const self = this;
+		if (!self._pendingSource) return;
+		try {
+			const currentSource = await this.crudContract.source.main.get(this.groupName, this.name);
+			const cleanPending = this.stripParameterCommentBlock(self._pendingSource);
+			const localBody = this.extractFunctionBody(cleanPending);
+			const sapBody = this.extractFunctionBody(currentSource);
+			if (this.normalizeSource(localBody) === this.normalizeSource(sapBody)) {
+				this._unchanged = true;
+				delete self._pendingSource;
+			}
+		} catch {}
+	}
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.functions.groups.fmodules.source.main.get(this.groupName, this.name);
+		});
+	}
+	/**
+	* Get a function module by name
+	*
+	* @param groupName - Parent function group name
+	* @param name - Function module name
+	* @param ctx - Optional ADK context (uses global if not provided)
+	*/
+	static async get(groupName, name, ctx) {
+		return new AdkFunctionModule(ctx ?? getGlobalContext(), groupName, name).load();
+	}
+	/**
+	* Check if a function module exists on SAP
+	*/
+	static async exists(groupName, name, ctx) {
+		try {
+			await AdkFunctionModule.get(groupName, name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP function module on SAP
+	*/
+	static async create(groupName, name, description, options, ctx) {
+		const fm = new AdkFunctionModule(ctx ?? getGlobalContext(), groupName.toUpperCase(), name.toUpperCase());
+		fm.setData({
+			name: name.toUpperCase(),
+			type: "FUGR/FF",
+			description,
+			processingType: options?.processingType ?? "normal"
+		});
+		await fm.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return fm;
+	}
+	/**
+	* Delete a function module from SAP
+	*/
+	static async delete(groupName, name, options, ctx) {
+		await new AdkFunctionModule(ctx ?? getGlobalContext(), groupName.toUpperCase(), name.toUpperCase()).crudContract.delete(groupName.toUpperCase(), name.toUpperCase(), {
+			corrNr: options?.transport,
+			lockHandle: options?.lockHandle
+		});
+	}
+};
+registerObjectType("FUGR/FF", FunctionModule, AdkFunctionModule, { endpoint: "functions/groups" });
+
+//#endregion
+//#region src/objects/ddic/doma/doma.model.ts
+/**
+* DOMA - Domain
+*
+* ADK object for ABAP Domains (DOMA).
+* DDIC objects are metadata-only (no source code).
+*/
+/**
+* ADK Domain object
+*
+* Inherits from AdkMainObject which provides:
+* - name, type, description, version, language, changedBy/At, createdBy/At, links
+* - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Domain-specific properties via `data`:
+* - data.typeInformation (dataType, length, decimals, outputLength)
+* - data.outputInformation (conversionExit, signPresentation, lowerCase)
+* - data.fixedValues
+*/
+var AdkDomain = class AdkDomain extends AdkMainObject {
+	static kind = Domain;
+	kind = AdkDomain.kind;
+	get objectUri() {
+		return `/sap/bc/adt/ddic/domains/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	get wrapperKey() {
+		return "domain";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.ddic.domains;
+	}
+	static async get(name, ctx) {
+		return new AdkDomain(ctx ?? getGlobalContext(), name).load();
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkDomain.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP domain on SAP.
+	*
+	* Note: Domains are metadata-only objects (no source code). After creation,
+	* use the `adt get domain <name>` command or abapGit-based deploy to fill in
+	* the domain properties (data type, field length, etc.).
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const domain = new AdkDomain(ctx ?? getGlobalContext(), name.toUpperCase());
+		domain.setData({
+			name: name.toUpperCase(),
+			type: "DOMA",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await domain.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return domain;
+	}
+	static async delete(name, options, ctx) {
+		await new AdkDomain(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			...options?.transport && { corrNr: options.transport },
+			...options?.lockHandle && { lockHandle: options.lockHandle }
+		});
+	}
+};
+registerObjectType("DOMA", Domain, AdkDomain, { endpoint: "ddic/domains" });
+
+//#endregion
+//#region src/objects/ddic/dtel/dtel.model.ts
+/**
+* DTEL - Data Element
+*
+* ADK object for ABAP Data Elements (DTEL).
+* DDIC objects are metadata-only (no source code).
+*/
+/**
+* ADK Data Element object
+*
+* Inherits from AdkMainObject which provides:
+* - name, type, description, version, language, changedBy/At, createdBy/At, links
+* - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Data element-specific properties via `data`:
+* - data.typeKind, data.typeName, data.dataType
+* - data.shortDescription, data.mediumDescription, data.longDescription, data.headingDescription
+* - data.searchHelp
+*/
+var AdkDataElement = class AdkDataElement extends AdkMainObject {
+	static kind = DataElement;
+	kind = AdkDataElement.kind;
+	get objectUri() {
+		return `/sap/bc/adt/ddic/dataelements/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	get wrapperKey() {
+		return "wbobj";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.ddic.dataelements;
+	}
+	static async get(name, ctx) {
+		return new AdkDataElement(ctx ?? getGlobalContext(), name).load();
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkDataElement.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP data element on SAP.
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const dtel = new AdkDataElement(ctx ?? getGlobalContext(), name.toUpperCase());
+		dtel.setData({
+			name: name.toUpperCase(),
+			type: "DTEL",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await dtel.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return dtel;
+	}
+	static async delete(name, options, ctx) {
+		await new AdkDataElement(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			...options?.transport && { corrNr: options.transport },
+			...options?.lockHandle && { lockHandle: options.lockHandle }
+		});
+	}
+};
+registerObjectType("DTEL", DataElement, AdkDataElement, { endpoint: "ddic/dataelements" });
+
+//#endregion
+//#region src/objects/ddic/tabl/tabl.model.ts
+/**
+* TABL - Database Table / Structure
+*
+* ADK object for ABAP Database Tables (TABL/DT) and Structures (TABL/DS).
+* Tables and structures are source-based DDIC objects whose definition
+* lives in ABAP source code (retrieved via sourceUri).
+*
+* Note: Tables and structures share the same ADT main type (TABL)
+* but use different endpoints and subtypes.
+* - Tables: /sap/bc/adt/ddic/tables (TABL/DT)
+* - Structures: /sap/bc/adt/ddic/structures (TABL/DS)
+*
+* SAP wraps both in a blue:blueSource root element
+* (namespace http://www.sap.com/wbobj/blue) extending AbapSourceMainObject.
+*/
+/**
+* ADK Table object (database table - TABL/DT)
+*/
+var AdkTable = class AdkTable extends AdkMainObject {
+	static kind = Table;
+	kind = AdkTable.kind;
+	get objectUri() {
+		return `/sap/bc/adt/ddic/tables/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/**
+	* Get CDS-style table source code from SAP
+	* Returns the ABAP source definition (annotations + field definitions)
+	*/
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.ddic.tables.source.main.get(this.name);
+		});
+	}
+	/**
+	* Get table technical settings (DD09L data)
+	* Returns XML from /sap/bc/adt/ddic/db/settings/{name}
+	*/
+	async getSettings() {
+		return this.lazy("settings", async () => {
+			return this.ctx.client.adt.ddic.tablesettings.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "blueSource";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.ddic.tables;
+	}
+	static async get(name, ctx) {
+		return new AdkTable(ctx ?? getGlobalContext(), name).load();
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkTable.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP database table on SAP.
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const table = new AdkTable(ctx ?? getGlobalContext(), name.toUpperCase());
+		table.setData({
+			name: name.toUpperCase(),
+			type: "TABL/DT",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await table.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return table;
+	}
+	static async delete(name, options, ctx) {
+		await new AdkTable(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			...options?.transport && { corrNr: options.transport },
+			...options?.lockHandle && { lockHandle: options.lockHandle }
+		});
+	}
+};
+/**
+* ADK Structure object (TABL/DS)
+*/
+var AdkStructure = class AdkStructure extends AdkMainObject {
+	static kind = Structure;
+	kind = AdkStructure.kind;
+	get objectUri() {
+		return `/sap/bc/adt/ddic/structures/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/**
+	* Get CDS-style structure source code from SAP
+	* Returns the ABAP source definition (annotations + field definitions)
+	*/
+	async getSource() {
+		return this.lazy("source", async () => {
+			return this.ctx.client.adt.ddic.structures.source.main.get(this.name);
+		});
+	}
+	get wrapperKey() {
+		return "blueSource";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.ddic.structures;
+	}
+	static async get(name, ctx) {
+		return new AdkStructure(ctx ?? getGlobalContext(), name).load();
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkStructure.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new ABAP structure on SAP.
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const struct = new AdkStructure(ctx ?? getGlobalContext(), name.toUpperCase());
+		struct.setData({
+			name: name.toUpperCase(),
+			type: "TABL/DS",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			packageRef: {
+				name: packageName.toUpperCase(),
+				uri: `/sap/bc/adt/packages/${encodeURIComponent(packageName.toUpperCase())}`,
+				type: "DEVC/K"
+			}
+		});
+		await struct.save({
+			transport: options?.transport,
+			mode: "create"
+		});
+		return struct;
+	}
+	static async delete(name, options, ctx) {
+		await new AdkStructure(ctx ?? getGlobalContext(), name.toUpperCase()).crudContract.delete(name.toUpperCase(), {
+			...options?.transport && { corrNr: options.transport },
+			...options?.lockHandle && { lockHandle: options.lockHandle }
+		});
+	}
+};
+registerObjectType("TABL", Table, AdkTable, { endpoint: "ddic/tables" });
+registerObjectType("TABL/DS", Structure, AdkStructure, { endpoint: "ddic/structures" });
+
+//#endregion
+//#region src/objects/ddic/ttyp/ttyp.model.ts
+/**
+* TTYP - Table Type
+*
+* ADK object for ABAP Table Types (TTYP).
+* DDIC objects are metadata-only (no source code).
+*/
+/**
+* ADK Table Type object
+*
+* Inherits from AdkMainObject which provides:
+* - name, type, description, version, language, changedBy/At, createdBy/At, links
+* - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+*
+* Table type-specific properties via `data`:
+* - data.rowType (typeName, typeCategory, tableTypeSchemaReference)
+* - data.primaryKey
+* - data.secondaryKeys
+*/
+var AdkTableType = class AdkTableType extends AdkMainObject {
+	static kind = TableType;
+	kind = AdkTableType.kind;
+	get objectUri() {
+		return `/sap/bc/adt/ddic/tabletypes/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	get wrapperKey() {
+		return "tableType";
+	}
+	get crudContract() {
+		return this.ctx.client.adt.ddic.tabletypes;
+	}
+	static async get(name, ctx) {
+		return new AdkTableType(ctx ?? getGlobalContext(), name).load();
+	}
+};
+registerObjectType("TTYP", TableType, AdkTableType, { endpoint: "ddic/tabletypes" });
+
+//#endregion
+//#region src/objects/cds/ddl.model.ts
+/**
+* DDL - CDS Data Definition Language Source (DDLS)
+*
+* ADK object for ABAP CDS Data Definition sources.
+* These are source-based objects stored at:
+*   GET/PUT /sap/bc/adt/ddic/ddl/sources/<name>/source/main
+*
+* The metadata document is at:
+*   GET /sap/bc/adt/ddic/ddl/sources/<name>
+*
+* Lock/activate/create follow the same patterns as other source objects.
+*/
+var AdkDdlSource = class AdkDdlSource {
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	get objectUri() {
+		return `/sap/bc/adt/ddic/ddl/sources/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — full metadata requires additional SAP fetch */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.ddic.ddl.sources;
+	}
+	async getSource() {
+		return toText(await this.contract.source.main.get(this.name));
+	}
+	async saveMainSource(source, options) {
+		await this.contract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "DDLS"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	/**
+	* Get a DDL source (does not fetch metadata, just returns handle)
+	*/
+	static async get(name, ctx) {
+		const obj = new AdkDdlSource(ctx ?? getGlobalContext(), name);
+		await obj.getSource();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkDdlSource.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new CDS DDL source on SAP
+	*
+	* POST /sap/bc/adt/ddic/ddl/sources?corrNr=...
+	* Body matches the `ddl:source` schema (extends abapsource:AbapSourceMainObject).
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.ddic.ddl.sources.post(options?.transport ? { corrNr: options.transport } : {}, { source: {
+			name: nameU,
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: "$TMP",
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkDdlSource(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.ddic.ddl.sources.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+};
+
+//#endregion
+//#region src/objects/cds/dcl.model.ts
+/**
+* DCL - CDS Access Control Definition Language Source (DCLS)
+*
+* ADK object for ABAP CDS Access Control (DCL) sources.
+* These are source-based objects stored at:
+*   GET/PUT /sap/bc/adt/acm/dcl/sources/<name>/source/main
+*
+* The metadata document is at:
+*   GET /sap/bc/adt/acm/dcl/sources/<name>
+*
+* Lock/activate/create follow the same patterns as DDL sources.
+*/
+var AdkDclSource = class AdkDclSource {
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	get objectUri() {
+		return `/sap/bc/adt/acm/dcl/sources/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — full metadata requires additional SAP fetch */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.ddic.dcl.sources;
+	}
+	async getSource() {
+		return toText(await this.contract.source.main.get(this.name));
+	}
+	async saveMainSource(source, options) {
+		await this.contract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "DCLS"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	static async get(name, ctx) {
+		const obj = new AdkDclSource(ctx ?? getGlobalContext(), name);
+		await obj.getSource();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkDclSource.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new CDS DCL source on SAP
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.ddic.dcl.sources.post(options?.transport ? { corrNr: options.transport } : {}, { source: {
+			name: nameU,
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: "$TMP",
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkDclSource(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.ddic.dcl.sources.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+};
+
+//#endregion
+//#region src/objects/repository/bdef/bdef.model.ts
+/**
+* BDEF - Behavior Definition (RAP)
+*
+* ADK object for ABAP RAP Behavior Definitions (BDEF).
+* These are source-based objects (`.abdl`) stored at:
+*   GET /sap/bc/adt/bo/behaviordefinitions/<name>
+*   GET/PUT /sap/bc/adt/bo/behaviordefinitions/<name>/source/main
+*
+* Lock/activate/create follow the same patterns as other source objects
+* (DDL, DCL). The metadata document uses the shared `blue:blueSource`
+* wrapper — same envelope as TABL/STRUCT.
+*
+* This class intentionally mirrors `AdkDdlSource` (lightweight ADK object,
+* not a full AdkMainObject subclass) because BDEF metadata is source-driven
+* and the typical lifecycle is: create skeleton → PUT source → activate.
+*/
+var AdkBehaviorDefinition = class AdkBehaviorDefinition {
+	/** Static ADK kind marker — used by abapGit handler registry if needed. */
+	static kind = "BehaviorDefinition";
+	kind = AdkBehaviorDefinition.kind;
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	get objectUri() {
+		return `/sap/bc/adt/bo/behaviordefinitions/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — full metadata requires additional SAP fetch */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.bo.behaviordefinitions;
+	}
+	async getSource() {
+		return toText(await this.contract.source.main.get(this.name));
+	}
+	async saveMainSource(source, options) {
+		await this.contract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "BDEF"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	/**
+	* Get a BDEF (validates it exists by fetching source).
+	*/
+	static async get(name, ctx) {
+		const obj = new AdkBehaviorDefinition(ctx ?? getGlobalContext(), name);
+		await obj.getSource();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkBehaviorDefinition.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new BDEF on SAP.
+	*
+	* POST /sap/bc/adt/bo/behaviordefinitions?corrNr=...
+	* Body matches the `blue:blueSource` envelope (extends
+	* abapsource:AbapSourceMainObject).
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.bo.behaviordefinitions.post(options?.transport ? { corrNr: options.transport } : {}, { blueSource: {
+			name: nameU,
+			type: "BDEF/BDO",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: pkgU,
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkBehaviorDefinition(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.bo.behaviordefinitions.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+};
+
+//#endregion
+//#region src/objects/repository/badi/badi.model.ts
+/**
+* BAdI — Enhancement Implementation (ENHO/XHH) — RAP-era BAdI container.
+*
+* ADK object for ABAP Enhancement Implementations that host BAdI
+* implementations. These live at:
+*
+*   GET    /sap/bc/adt/enhancements/enhoxhh/<name>
+*   PUT    /sap/bc/adt/enhancements/enhoxhh/<name>
+*   DELETE /sap/bc/adt/enhancements/enhoxhh/<name>
+*   GET/PUT /sap/bc/adt/enhancements/enhoxhh/<name>/source/main
+*
+* Mirrors the source-driven pattern used by `AdkBehaviorDefinition`
+* (BDEF): create skeleton → PUT source → activate.
+*
+* sapcli reference: `sap/cli/badi.py` (`_get_enhancement_implementation`).
+*/
+var AdkBadi = class AdkBadi {
+	/** Static ADK kind marker. */
+	static kind = "Badi";
+	kind = AdkBadi.kind;
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	/** ADT URI (lowercase path segment — SAP convention). */
+	get objectUri() {
+		return `/sap/bc/adt/enhancements/enhoxhh/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — real metadata arrives via GET/objectstructure. */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.enhancements.enhoxhh;
+	}
+	async getMetadata() {
+		return await this.contract.get(this.name);
+	}
+	async getSource() {
+		return toText(await this.contract.source.main.get(this.name));
+	}
+	async saveMainSource(source, options) {
+		await this.contract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "ENHO"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	/** Fetch a BAdI / ENHO, validating existence via a metadata GET. */
+	static async get(name, ctx) {
+		const obj = new AdkBadi(ctx ?? getGlobalContext(), name);
+		await obj.getMetadata();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkBadi.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new Enhancement Implementation (BAdI container).
+	*
+	* Trial systems typically reject this with HTTP 403 — this is an
+	* area that requires elevated authorisation on most SAP installs.
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.enhancements.enhoxhh.post(options?.transport ? { corrNr: options.transport } : {}, { enhancementImplementation: {
+			name: nameU,
+			type: "ENHO/XHH",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: pkgU,
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkBadi(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.enhancements.enhoxhh.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+};
+
+//#endregion
+//#region src/objects/repository/srvd/srvd.model.ts
+/**
+* SRVD - Service Definition (RAP)
+*
+* ADK object for ABAP RAP Service Definitions (SRVD).
+* Source-based objects (`.asrvd`) stored at:
+*   GET /sap/bc/adt/ddic/srvd/sources/<name>
+*   GET/PUT /sap/bc/adt/ddic/srvd/sources/<name>/source/main
+*
+* Lock/activate/create follow the same patterns as other source objects
+* (DDL, DCL, BDEF). Metadata envelope is the dedicated `srvd:source`
+* wrapper extending abapsource:AbapSourceMainObject (mirrors DDL).
+*/
+var AdkServiceDefinition = class AdkServiceDefinition {
+	/** Static ADK kind marker — used by abapGit handler registry if needed. */
+	static kind = "ServiceDefinition";
+	kind = AdkServiceDefinition.kind;
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	get objectUri() {
+		return `/sap/bc/adt/ddic/srvd/sources/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — full metadata requires additional SAP fetch */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.ddic.srvd.sources;
+	}
+	async getSource() {
+		return toText(await this.contract.source.main.get(this.name));
+	}
+	async saveMainSource(source, options) {
+		await this.contract.source.main.put(this.name, {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.transport ? { corrNr: options.transport } : {}
+		}, source);
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "SRVD"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	/**
+	* Get a SRVD (validates it exists by fetching source).
+	*/
+	static async get(name, ctx) {
+		const obj = new AdkServiceDefinition(ctx ?? getGlobalContext(), name);
+		await obj.getSource();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkServiceDefinition.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new SRVD on SAP.
+	*
+	* POST /sap/bc/adt/ddic/srvd/sources?corrNr=...
+	* Body matches the `srvd:source` envelope (extends
+	* abapsource:AbapSourceMainObject).
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.ddic.srvd.sources.post(options?.transport ? { corrNr: options.transport } : {}, { source: {
+			name: nameU,
+			type: "SRVD/SRV",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: pkgU,
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkServiceDefinition(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.ddic.srvd.sources.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+};
+
+//#endregion
+//#region src/objects/repository/srvb/srvb.model.ts
+/**
+* SRVB - Service Binding (RAP)
+*
+* ADK object for ABAP RAP Service Bindings (SRVB). Unlike BDEF/SRVD,
+* SRVB is **metadata-only** — there is no source text. The binding
+* XML carries the service + protocol references.
+*
+*   GET    /sap/bc/adt/businessservices/bindings/<name>
+*   POST   /sap/bc/adt/businessservices/bindings
+*   PUT    /sap/bc/adt/businessservices/bindings/<name>
+*   DELETE /sap/bc/adt/businessservices/bindings/<name>
+*   POST   /sap/bc/adt/businessservices/bindings/<name>/publishedstates  (publish)
+*   DELETE /sap/bc/adt/businessservices/bindings/<name>/publishedstates  (unpublish)
+*
+* Lifecycle follows lock/activate patterns from sibling RAP objects.
+*/
+var AdkServiceBinding = class AdkServiceBinding {
+	/** Static ADK kind marker — used by abapGit handler registry if needed. */
+	static kind = "ServiceBinding";
+	kind = AdkServiceBinding.kind;
+	name;
+	ctx;
+	constructor(ctx, name) {
+		this.ctx = ctx;
+		this.name = name.toUpperCase();
+	}
+	get objectUri() {
+		return `/sap/bc/adt/businessservices/bindings/${encodeURIComponent(this.name.toLowerCase())}`;
+	}
+	/** Placeholder description — full metadata requires additional SAP fetch */
+	get description() {
+		return this.name;
+	}
+	get contract() {
+		return this.ctx.client.adt.businessservices.bindings;
+	}
+	/**
+	* Fetch the binding metadata document. SRVB has no source text;
+	* `getSource()` returns an empty string for uniform CLI parity.
+	*/
+	async getMetadata() {
+		return this.contract.get(this.name);
+	}
+	async getSource() {
+		return "";
+	}
+	async lock(transport) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Lock not available: no lockService in context. Did you call initializeAdk()?");
+		return lockService.lock(this.objectUri, {
+			transport,
+			objectName: this.name,
+			objectType: "SRVB"
+		});
+	}
+	async unlock(lockHandle) {
+		const lockService = this.ctx.lockService;
+		if (!lockService) throw new Error("Unlock not available: no lockService in context. Did you call initializeAdk()?");
+		await lockService.unlock(this.objectUri, { lockHandle });
+	}
+	async activate() {
+		await this.ctx.client.adt.activation.activate.post({}, { objectReferences: { objectReference: [{
+			uri: this.objectUri,
+			name: this.name
+		}] } });
+		return this;
+	}
+	/**
+	* Publish (activate) the binding in the SAP Gateway.
+	* POST {basePath}/{name}/publishedstates
+	*/
+	async publish() {
+		await this.contract.publish(this.name);
+	}
+	/**
+	* Unpublish (deactivate) the binding.
+	* DELETE {basePath}/{name}/publishedstates
+	*/
+	async unpublish() {
+		await this.contract.unpublish(this.name);
+	}
+	/**
+	* Get a SRVB (validates it exists by fetching metadata).
+	*/
+	static async get(name, ctx) {
+		const obj = new AdkServiceBinding(ctx ?? getGlobalContext(), name);
+		await obj.getMetadata();
+		return obj;
+	}
+	static async exists(name, ctx) {
+		try {
+			await AdkServiceBinding.get(name, ctx);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new SRVB on SAP.
+	*
+	* POST /sap/bc/adt/businessservices/bindings?corrNr=...
+	* Body matches the `srvb:serviceBinding` envelope.
+	*/
+	static async create(name, description, packageName, options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const nameU = name.toUpperCase();
+		const pkgU = packageName.toUpperCase();
+		await context.client.adt.businessservices.bindings.post(options?.transport ? { corrNr: options.transport } : {}, { serviceBinding: {
+			name: nameU,
+			type: "SRVB/SVB",
+			description,
+			language: "EN",
+			masterLanguage: "EN",
+			responsible: pkgU,
+			packageRef: {
+				name: pkgU,
+				type: "DEVC/K",
+				uri: `/sap/bc/adt/packages/${pkgU.toLowerCase()}`
+			}
+		} });
+		return new AdkServiceBinding(context, nameU);
+	}
+	static async delete(name, options, ctx) {
+		await (ctx ?? getGlobalContext()).client.adt.businessservices.bindings.delete(name.toUpperCase(), {
+			...options?.transport ? { corrNr: options.transport } : {},
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {}
+		});
+	}
+	static async publish(name, ctx) {
+		await new AdkServiceBinding(ctx ?? getGlobalContext(), name).publish();
+	}
+	static async unpublish(name, ctx) {
+		await new AdkServiceBinding(ctx ?? getGlobalContext(), name).unpublish();
+	}
+};
+
+//#endregion
+//#region src/objects/cts/transport/transport-object.ts
+/**
+* Transport Object - wrapper for ABAP objects in a transport
+*/
+var AdkTransportObject = class {
+	constructor(data) {
+		this.data = data;
+	}
+	get pgmid() {
+		return this.data.pgmid || "";
+	}
+	get type() {
+		return this.data.type || "";
+	}
+	get name() {
+		return this.data.name || "";
+	}
+	get wbtype() {
+		return this.data.wbtype;
+	}
+	get objectInfo() {
+		return this.data.obj_info;
+	}
+	get objectDescription() {
+		return this.data.obj_desc;
+	}
+	get lockStatus() {
+		return this.data.lock_status;
+	}
+	get uri() {
+		return this.data.uri;
+	}
+	/** Full object key (PGMID/TYPE/NAME) */
+	get key() {
+		return `${this.pgmid}/${this.type}/${this.name}`;
+	}
+	/** Raw schema data */
+	get raw() {
+		return this.data;
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/objects/cts/transport/transport.ts
+const STATUS_TEXT = {
+	D: "Modifiable",
+	R: "Released",
+	N: "Not released"
+};
+function asArray$1(val) {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
+}
+let cachedConfigUri;
+async function getConfigUri(ctx) {
+	if (cachedConfigUri) return cachedConfigUri;
+	const configs = (await ctx.client.adt.cts.transportrequests.searchconfiguration.configurations.get())?.configurations;
+	if (!configs) throw new Error("No search configuration found");
+	const configArray = Array.isArray(configs) ? configs : [configs];
+	if (configArray.length === 0) throw new Error("No search configuration found");
+	const uri = configArray[0]?.link?.href;
+	if (!uri) throw new Error("No search configuration URI found");
+	cachedConfigUri = uri;
+	return uri;
+}
+/** Clear config cache (for testing) */
+function clearConfigCache() {
+	cachedConfigUri = void 0;
+}
+/**
+* Collect all requests from the transport response structure
+* The schema has requests in multiple places:
+* - workbench.modifiable.request[]
+* - workbench.relstarted.request[]
+* - workbench.released.request[]
+* - workbench.target[].modifiable.request[]
+* - customizing.* (same structure)
+*/
+function collectAllRequests(result) {
+	const requests = [];
+	if (!result || typeof result !== "object") return requests;
+	const data = result;
+	const extractFromContainer = (container) => {
+		if (!container || typeof container !== "object") return;
+		const reqs = container.request;
+		if (reqs) {
+			const reqArray = Array.isArray(reqs) ? reqs : [reqs];
+			requests.push(...reqArray);
+		}
+	};
+	const processSection = (section) => {
+		if (!section || typeof section !== "object") return;
+		const s = section;
+		extractFromContainer(s.modifiable);
+		extractFromContainer(s.relstarted);
+		extractFromContainer(s.released);
+		const targets = s.target;
+		if (targets) {
+			const targetArray = Array.isArray(targets) ? targets : [targets];
+			for (const target of targetArray) if (target && typeof target === "object") {
+				const t = target;
+				extractFromContainer(t.modifiable);
+				extractFromContainer(t.relstarted);
+				extractFromContainer(t.released);
+			}
+		}
+	};
+	processSection(data.workbench);
+	processSection(data.customizing);
+	return requests;
+}
+/**
+* Transport Request - main transport object
+*
+* Handles both requests (K) and can be extended for tasks (T).
+* Uses ADT contracts directly - no intermediate service layer.
+*/
+var AdkTransportRequest = class AdkTransportRequest extends AdkObject {
+	kind = TransportRequest;
+	_tasks;
+	_objects;
+	constructor(ctx, dataOrNumber) {
+		if (typeof dataOrNumber === "string") super(ctx, dataOrNumber);
+		else super(ctx, {
+			name: dataOrNumber.name || dataOrNumber.request?.number || "",
+			type: dataOrNumber.object_type === "T" ? "RQTQ" : "RQRQ",
+			response: dataOrNumber
+		});
+	}
+	get response() {
+		return this.dataSync.response;
+	}
+	/** The item's data - override in subclass for different source */
+	get itemData() {
+		return this.response.request || {};
+	}
+	get objectUri() {
+		return `/sap/bc/adt/cts/transportrequests/${this.name}`;
+	}
+	async load() {
+		const response = (await this.ctx.client.adt.cts.transportrequests.get(this.name)).root;
+		this.setData({
+			name: this.name,
+			type: response.object_type === "T" ? "RQTQ" : "RQRQ",
+			response
+		});
+		return this;
+	}
+	get itemType() {
+		return this.response.object_type === "T" ? "task" : "request";
+	}
+	get number() {
+		return this.name;
+	}
+	get owner() {
+		return this.itemData.owner || "";
+	}
+	get description() {
+		return this.itemData.desc || "";
+	}
+	get status() {
+		return this.itemData.status || "D";
+	}
+	get statusText() {
+		return this.itemData.status_text || STATUS_TEXT[this.status] || this.status;
+	}
+	get target() {
+		return this.itemData.target || "";
+	}
+	get targetDescription() {
+		return this.itemData.target_desc || "";
+	}
+	get uri() {
+		return this.itemData.uri || this.objectUri;
+	}
+	get parent() {
+		return this.itemData.parent || "";
+	}
+	get lastChangedAt() {
+		return parseSapTimestamp(this.itemData.lastchanged_timestamp);
+	}
+	/** Tasks belonging to this transport request */
+	get tasks() {
+		if (!this._tasks) {
+			const taskData = this.itemData.task;
+			this._tasks = asArray$1(taskData).map((t) => {
+				const { request, task: _existingTasks, ...rootProps } = this.response;
+				const { task: _nestedTasks, ...requestWithoutTasks } = request || {};
+				const taskResponse = {
+					...rootProps,
+					object_type: "T",
+					name: t.number || "",
+					request: request ? requestWithoutTasks : void 0,
+					task: [t]
+				};
+				return new AdkTransportTask(this.ctx, taskResponse, this);
+			});
+		}
+		return this._tasks;
+	}
+	/**
+	* All objects in this request (aggregated from tasks)
+	* Override in AdkTransportTask for direct objects
+	*/
+	get objects() {
+		if (!this._objects) {
+			const directObjects = asArray$1(this.itemData.abap_object).map((o) => new AdkTransportObject(o));
+			const taskObjects = this.tasks.flatMap((t) => t.objects);
+			this._objects = [...directObjects, ...taskObjects];
+		}
+		return this._objects;
+	}
+	async release() {
+		try {
+			await this.ctx.client.adt.cts.transportrequests.useraction.release(this.number, { root: { useraction: "release" } });
+			this.itemData.status = "R";
+			this.itemData.status_text = "Released";
+			return { success: true };
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	async releaseAll() {
+		for (const task of this.tasks) if (task.status !== "R") {
+			const result = await task.release();
+			if (!result.success) return {
+				success: false,
+				message: `Failed to release task ${task.number}: ${result.message}`
+			};
+		}
+		return this.release();
+	}
+	async update(changes) {
+		await this.ctx.client.adt.cts.transportrequests.put(this.number, {
+			desc: changes.description ?? this.description,
+			target: changes.target ?? this.target
+		});
+		if (changes.description !== void 0) this.itemData.desc = changes.description;
+		if (changes.target !== void 0) this.itemData.target = changes.target;
+	}
+	async delete() {
+		await this.ctx.client.adt.cts.transportrequests.delete(this.number);
+	}
+	/**
+	* Reassign ownership of this transport (and optionally all tasks) to a new user.
+	*
+	* @param newOwner - SAP username to become the new owner
+	* @param recursive - When true, also reassign all modifiable tasks
+	*/
+	async reassign(newOwner, recursive = false) {
+		await this.ctx.client.adt.cts.transportrequests.useraction.reassign(this.number, {
+			targetUser: newOwner,
+			recursive
+		}, { root: {
+			useraction: "changeowner",
+			targetuser: newOwner
+		} });
+		this.itemData.owner = newOwner;
+		if (recursive) {
+			for (const task of this.tasks) if (task.status !== "R") await task.reassign(newOwner);
+		}
+	}
+	/**
+	* Create a new transport request
+	*
+	* @param options - Transport creation options
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async create(options, ctx) {
+		const context = ctx ?? getGlobalContext();
+		let owner = options.owner;
+		if (!owner) owner = await AdkTransportRequest.getCurrentUser(context);
+		const response = await context.client.adt.cts.transportrequests.useraction.create({
+			description: options.description,
+			type: options.type,
+			target: options.target,
+			project: options.project,
+			owner
+		}, { root: {
+			useraction: "newrequest",
+			request: {
+				desc: options.description,
+				type: options.type || "K",
+				target: options.target || "LOCAL",
+				cts_project: options.project || "",
+				task: [{ owner }]
+			}
+		} });
+		const number = response?.root?.request?.number ?? response?.root?.name ?? void 0;
+		if (!number) throw new Error("Failed to create transport - no number returned");
+		return AdkTransportRequest.get(number, context);
+	}
+	/**
+	* Get a transport request by number
+	*
+	* @param number - Transport number (e.g., 'S0DK900001')
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async get(number, ctx) {
+		const context = ctx ?? getGlobalContext();
+		const response = (await context.client.adt.cts.transportrequests.get(number)).root;
+		if (response.object_type === "T") return new AdkTransportTask(context, response);
+		return new AdkTransportRequest(context, response);
+	}
+	/**
+	* List all transports for the current user
+	*
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async list(ctx) {
+		const context = ctx ?? getGlobalContext();
+		const configUri = await getConfigUri(context);
+		return collectAllRequests(await context.client.adt.cts.transportrequests.list({
+			targets: "true",
+			configUri
+		})).map((r) => new AdkTransportRequest(context, {
+			name: r.number || "",
+			object_type: "K",
+			request: {
+				number: r.number,
+				owner: r.owner,
+				desc: r.desc,
+				status: r.status,
+				uri: r.uri,
+				task: r.task,
+				abap_object: r.abap_object
+			}
+		}));
+	}
+	/**
+	* Get current user from the system metadata
+	*
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async getCurrentUser(ctx) {
+		const user = ((await (ctx ?? getGlobalContext()).client.adt.cts.transportrequests.searchconfiguration.metadata.get())?.configuration?.properties?.property ?? []).find((p) => p.key === "User")?.$value?.trim();
+		if (user) return user;
+		throw new Error("Could not detect current user from metadata response");
+	}
+};
+__decorate([
+	requiresLock(),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object]),
+	__decorateMetadata("design:returntype", Promise)
+], AdkTransportRequest.prototype, "update", null);
+/**
+* Transport Task - child of a transport request
+*
+* Minimal overrides:
+* - itemData: from response.task instead of response.request
+* - objects: direct from task, not aggregated
+* - request: parent reference
+* - No tasks, no CRUD
+*/
+var AdkTransportTask = class AdkTransportTask extends AdkTransportRequest {
+	_parentRequest;
+	parentRef;
+	constructor(ctx, dataOrNumber, parentRef) {
+		super(ctx, dataOrNumber);
+		this.parentRef = parentRef;
+	}
+	get itemData() {
+		const rootTask = this.response.task;
+		if (rootTask) {
+			const taskArr = Array.isArray(rootTask) ? rootTask : [rootTask];
+			const found = taskArr.find((t) => t.number === this.name) || taskArr[0];
+			if (found) return found;
+		}
+		return this.response.request || {};
+	}
+	get tasks() {
+		return [];
+	}
+	get objects() {
+		if (!this._objects) {
+			const taskData = this.itemData;
+			this._objects = asArray$1(taskData?.abap_object).map((o) => new AdkTransportObject(o));
+		}
+		return this._objects;
+	}
+	/** Parent transport request */
+	get request() {
+		if (this.parentRef) return this.parentRef;
+		if (!this._parentRequest) {
+			const parentNumber = this.response.request?.number || this.parent;
+			this._parentRequest = new AdkTransportRequest(this.ctx, {
+				...this.response,
+				name: parentNumber,
+				object_type: "K"
+			});
+		}
+		return this._parentRequest;
+	}
+	/**
+	* Get a transport task by number
+	*
+	* @param number - Task number (e.g., 'S0DK900001')
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*/
+	static async get(number, ctx) {
+		const context = ctx ?? getGlobalContext();
+		return new AdkTransportTask(context, (await context.client.adt.cts.transportrequests.get(number)).root);
+	}
+};
+
+//#endregion
+//#region src/objects/cts/transport-import.ts
+/**
+* Helper to normalize array/single value to array
+*/
+function asArray(val) {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
+}
+/**
+* Check if a value matches a selector dimension.
+*
+* - If `expected` is undefined → no filter (always matches).
+* - If `expected` is '*' → matches any truthy value.
+* - If `expected` is an array → value must be in the array.
+* - Otherwise exact match (case-insensitive).
+*/
+function matchesDimension(value, expected) {
+	if (expected === void 0) return true;
+	if (Array.isArray(expected)) return expected.some((e) => e === "*" ? !!value : e.toUpperCase() === value.toUpperCase());
+	if (expected === "*") return !!value;
+	return expected.toUpperCase() === value.toUpperCase();
+}
+/**
+* Check if an object ref matches all dimensions of a {@link TransportObjectSelector}.
+*
+* Exported so that consumers (e.g. import service) can reuse the same logic
+* without duplicating it.
+*/
+function matchesSelector(obj, selector) {
+	return matchesDimension(obj.objFunc, selector.objFunc) && matchesDimension(obj.pgmid, selector.pgmid) && matchesDimension(obj.type, selector.type);
+}
+/**
+* Transport object reference - lightweight wrapper
+*
+* Contains metadata about an object in the transport.
+* Call load() to get the full ADK object.
+*/
+var AdkTransportObjectRef = class {
+	constructor(ctx, data) {
+		this.ctx = ctx;
+		this.data = data;
+	}
+	/** Program ID (R3TR, LIMU, etc.) */
+	get pgmid() {
+		return this.data.pgmid ?? "";
+	}
+	/** Object type (CLAS, INTF, DOMA, etc.) */
+	get type() {
+		return this.data.type ?? "";
+	}
+	/** Object name */
+	get name() {
+		return this.data.name ?? "";
+	}
+	/** Workbench type (more specific type) */
+	get wbtype() {
+		return this.data.wbtype;
+	}
+	/** Object URI for direct access */
+	get uri() {
+		return this.data.uri;
+	}
+	/** Object description */
+	get description() {
+		return this.data.obj_desc;
+	}
+	/**
+	* Object function code (SAP OBJFUNC).
+	* 'D' = marked for deletion, 'K' = key entry, '' = regular modification.
+	*/
+	get objFunc() {
+		return this.data.obj_func ?? "";
+	}
+	/** Whether this object is marked for deletion (obj_func === 'D') */
+	get isDeleted() {
+		return this.data.obj_func === "D";
+	}
+	/** Full object key (PGMID/TYPE/NAME) */
+	get key() {
+		return `${this.pgmid}/${this.type}/${this.name}`;
+	}
+	/**
+	* Load the full ADK object
+	*
+	* Uses the ADK factory to create the appropriate object type
+	* (AdkClass, AdkInterface, AdkPackage, etc.)
+	*
+	* @returns The loaded ADK object, or undefined if type not supported
+	*/
+	async load() {
+		const { createAdk } = await import("./factory-DtyrTGlN.mjs").then((n) => n.i);
+		const adk = createAdk(this.ctx.client);
+		try {
+			const obj = adk.get(this.name, this.type);
+			if ("load" in obj && typeof obj.load === "function") await obj.load();
+			return obj;
+		} catch {
+			return;
+		}
+	}
+	/** Raw data from API */
+	get raw() {
+		return this.data;
+	}
+};
+/**
+* Transport task reference
+*/
+var AdkTransportTaskRef = class {
+	constructor(ctx, data) {
+		this.ctx = ctx;
+		this.data = data;
+	}
+	get number() {
+		return this.data.number ?? "";
+	}
+	get owner() {
+		return this.data.owner ?? "";
+	}
+	get description() {
+		return this.data.desc ?? "";
+	}
+	get status() {
+		return this.data.status ?? "";
+	}
+	get statusText() {
+		return this.data.status_text ?? "";
+	}
+	/** Objects in this task */
+	get objects() {
+		return asArray(this.data.abap_object).map((obj) => new AdkTransportObjectRef(this.ctx, obj));
+	}
+};
+/**
+* AdkTransport - Transport request for import operations
+*
+* Simple, focused API for importing transport objects:
+*
+* @example
+* ```typescript
+* const transport = await AdkTransport.get('DEVK900001');
+*
+* for (const objRef of transport.objects) {
+*   console.log(`${objRef.type} ${objRef.name}`);
+*   const adkObject = await objRef.load();
+*   if (adkObject) {
+*     // Serialize with plugin
+*     await plugin.serialize(adkObject);
+*   }
+* }
+* ```
+*/
+var AdkTransport = class AdkTransport {
+	_objects;
+	_tasks;
+	constructor(ctx, data) {
+		this.ctx = ctx;
+		this.data = data;
+	}
+	/** Transport number */
+	get number() {
+		return this.data.name ?? this.data.request?.number ?? "";
+	}
+	/** Transport description */
+	get description() {
+		return this.data.request?.desc ?? "";
+	}
+	/** Transport owner */
+	get owner() {
+		return this.data.request?.owner ?? "";
+	}
+	/** Transport status (D=Modifiable, R=Released) */
+	get status() {
+		return this.data.request?.status ?? "";
+	}
+	/** Transport status text */
+	get statusText() {
+		return this.data.request?.status_text ?? "";
+	}
+	/** Transport target system */
+	get target() {
+		return this.data.request?.target ?? "";
+	}
+	/** Object type (K=Request, T=Task) */
+	get objectType() {
+		return this.data.object_type ?? "K";
+	}
+	/** Tasks belonging to this transport */
+	get tasks() {
+		if (!this._tasks) {
+			const requestTasks = asArray(this.data.request?.task);
+			const rootTasks = asArray(this.data.task);
+			this._tasks = [...requestTasks, ...rootTasks].map((t) => new AdkTransportTaskRef(this.ctx, t));
+		}
+		return this._tasks;
+	}
+	/**
+	* All objects in this transport
+	*
+	* Collects objects from:
+	* - Direct objects on request
+	* - Objects from all tasks
+	* - all_objects container (if present)
+	*/
+	get objects() {
+		if (!this._objects) this._objects = this.collectObjects();
+		return this._objects;
+	}
+	collectObjects() {
+		const objects = [];
+		const seen = /* @__PURE__ */ new Set();
+		const addObject = (obj) => {
+			const key = `${obj.pgmid}/${obj.type}/${obj.name}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				objects.push(new AdkTransportObjectRef(this.ctx, obj));
+			}
+		};
+		for (const obj of asArray(this.data.request?.abap_object)) addObject(obj);
+		for (const obj of asArray(this.data.request?.all_objects?.abap_object)) addObject(obj);
+		for (const task of this.tasks) for (const objRef of task.objects) addObject(objRef.raw);
+		return objects;
+	}
+	/**
+	* Get objects filtered by type
+	*
+	* @param types - Object types to include (e.g., ['CLAS', 'INTF'])
+	*/
+	getObjectsByType(...types) {
+		const typeSet = new Set(types.map((t) => t.toUpperCase()));
+		return this.objects.filter((obj) => typeSet.has(obj.type.toUpperCase()));
+	}
+	/**
+	* Get objects filtered by a {@link TransportObjectSelector}.
+	*
+	* All dimensions specified in the selector are ANDed together.
+	*
+	* @example
+	* ```typescript
+	* // Get only deletion objects with pgmid=R3TR
+	* const deleted = transport.getObjectsBySelector({ objFunc: 'D', pgmid: 'R3TR' });
+	* ```
+	*/
+	getObjectsBySelector(selector) {
+		return this.objects.filter((obj) => matchesSelector(obj, selector));
+	}
+	/**
+	* Convenience accessor for objects marked for deletion (obj_func === 'D').
+	*
+	* Equivalent to `getObjectsBySelector({ objFunc: 'D' })`.
+	*/
+	get deletionObjects() {
+		return this.getObjectsBySelector({ objFunc: "D" });
+	}
+	/**
+	* Get unique object types in this transport
+	*/
+	getObjectTypes() {
+		const types = new Set(this.objects.map((obj) => obj.type));
+		return Array.from(types).sort();
+	}
+	/**
+	* Get object count by type
+	*/
+	getObjectCountByType() {
+		const counts = {};
+		for (const obj of this.objects) counts[obj.type] = (counts[obj.type] || 0) + 1;
+		return counts;
+	}
+	/** Raw API response (unwrapped) */
+	get raw() {
+		return this.data;
+	}
+	/**
+	* Get a transport by number
+	*
+	* @param number - Transport number (e.g., 'DEVK900001')
+	* @param ctx - Optional ADK context (uses global context if not provided)
+	*
+	* @example
+	* ```typescript
+	* const transport = await AdkTransport.get('DEVK900001');
+	* console.log(`${transport.description} - ${transport.objects.length} objects`);
+	* ```
+	*/
+	static async get(number, ctx) {
+		const context = ctx ?? getGlobalContext();
+		return new AdkTransport(context, (await context.client.adt.cts.transportrequests.get(number)).root);
+	}
+	/**
+	* Load multiple transports and merge their objects into a single view.
+	*
+	* De-duplication key is `pgmid/type/name`. When the same key appears in
+	* multiple transports the **first** occurrence wins (first transport in the
+	* `numbers` array). The source transport number is available via
+	* `AdkTransportObjectRef.sourceTransport`.
+	*
+	* @param numbers - Transport numbers to load and merge
+	* @param ctx     - Optional ADK context
+	*
+	* @example
+	* ```typescript
+	* const merged = await AdkTransport.merge(['DEVK900001', 'DEVK900002']);
+	* const deletions = merged.getObjectsBySelector({ objFunc: 'D' });
+	* ```
+	*/
+	static async merge(numbers, ctx) {
+		return new MergedTransportView(await Promise.all(numbers.map((n) => AdkTransport.get(n, ctx))));
+	}
+};
+function getFilteredObjects(transport, selector) {
+	return Object.keys(selector).length > 0 ? transport.getObjectsBySelector(selector) : transport.objects;
+}
+function addResolvedObject(object, sourceTransport, objects, sourceTransportMap, seenKeys) {
+	if (seenKeys && seenKeys.has(object.key)) return;
+	if (seenKeys) seenKeys.add(object.key);
+	objects.push(object);
+	sourceTransportMap.set(object.key, sourceTransport);
+}
+/**
+* Load and resolve objects from one or more transport numbers, with optional
+* selector-based filtering and deduplication across TRs.
+*
+* This is the shared logic used by both the CLI `cts tr objects` command and
+* the MCP `cts_transport_objects` tool — extracted here to avoid duplication.
+*
+* @param transportNumbers - Ordered list of TR numbers (first-win deduplication).
+* @param selector         - Optional dimension filter (objFunc, pgmid, type).
+* @param ctx              - Optional ADK context (uses global context if omitted).
+*/
+async function resolveTransportObjects(transportNumbers, selector, ctx) {
+	const objects = [];
+	const sourceTransportMap = /* @__PURE__ */ new Map();
+	if (transportNumbers.length === 1) {
+		const primaryNumber = transportNumbers[0] ?? "";
+		const tr = await AdkTransport.get(primaryNumber, ctx);
+		for (const object of getFilteredObjects(tr, selector)) addResolvedObject(object, primaryNumber, objects, sourceTransportMap);
+	} else {
+		const transports = await Promise.all(transportNumbers.map((n) => AdkTransport.get(n, ctx)));
+		const seen = /* @__PURE__ */ new Set();
+		for (const tr of transports) for (const object of getFilteredObjects(tr, selector)) addResolvedObject(object, tr.number, objects, sourceTransportMap, seen);
+	}
+	return {
+		objects,
+		sourceTransportMap
+	};
+}
+/**
+* Merged view of objects from multiple transports.
+*
+* De-duplicates by `pgmid/type/name`; first occurrence wins.
+*/
+var MergedTransportView = class MergedTransportView {
+	_objects;
+	transports;
+	constructor(transports) {
+		this.transports = transports;
+		const seen = /* @__PURE__ */ new Set();
+		const all = [];
+		for (const tr of transports) for (const obj of tr.objects) if (!seen.has(obj.key)) {
+			seen.add(obj.key);
+			all.push(obj);
+		}
+		this._objects = all;
+	}
+	/** All objects across transports (deduplicated) */
+	get objects() {
+		return this._objects;
+	}
+	/** Objects matching a selector across all transports */
+	getObjectsBySelector(selector) {
+		return this._objects.filter((obj) => matchesSelector(obj, selector));
+	}
+	/** Convenience: objects marked for deletion (obj_func === 'D') */
+	get deletionObjects() {
+		return this.getObjectsBySelector({ objFunc: "D" });
+	}
+	/**
+	* Load multiple transports and return a merged view.
+	*
+	* @param numbers - Transport numbers to load and merge
+	* @param ctx     - Optional ADK context
+	*/
+	static async create(numbers, ctx) {
+		return new MergedTransportView(await Promise.all(numbers.map((n) => AdkTransport.get(n, ctx))));
+	}
+};
+
+//#endregion
+export { ADT_TYPE_MAPPINGS, AdkBadi, AdkBehaviorDefinition, AdkClass, AdkDataElement, AdkDclSource, AdkDdlSource, AdkDomain, AdkFunctionGroup, AdkFunctionModule, AdkGenericObject, AdkInclude, AdkInterface, AdkMainObject, AdkObject, AdkObjectSet, AdkPackage, AdkProgram, AdkServiceBinding, AdkServiceDefinition, AdkStructure, AdkTable, AdkTableType, AdkTransport, AdkTransportRequest as AdkTransportItem, AdkTransportRequest, AdkTransportObject, AdkTransportObjectRef, AdkTransportTask, AdkTransportTaskRef, Class, DataElement, Domain, EnhancementSpot, FunctionGroup, FunctionModule, Include, Interface, MergedTransportView, MessageClass, Package, Program, Structure, Table, TableType, TransportRequest, TransportTask, clearConfigCache, createAdk, createAdkContract, createAdkFactory, createLockService, getEndpointForType, getGlobalContext, getKindForType, getMainType, getObjectRootUri, getObjectUri, getRegisteredKinds, getRegisteredTypes, getTypeForKind, initializeAdk, isAdkInitialized, isTypeRegistered, matchesSelector, normalizeObjectName, parseAdtType, parseXmlIdentity, registerObjectType, resetAdk, resolveKind, resolveTransportObjects, resolveType, tryGetGlobalContext };
+//# sourceMappingURL=index.mjs.map