@likec4/leanix-bridge 1.53.0

package/dist/index.mjs

@@ -0,0 +1,1110 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+* Canonical bridge contracts for LikeC4 ↔ LeanIX interoperability.
+* LikeC4 remains the semantic source of truth; external IDs are provider-scoped.
+* Uses readFileSync (not require) so when bundled into likec4 CLI the bundler
+* does not emit require('../package.json') which fails in the tarball layout.
+*/
+const _dir = dirname(fileURLToPath(import.meta.url));
+function readVersion() {
+	try {
+		return JSON.parse(readFileSync(join(_dir, "..", "package.json"), "utf8")).version ?? "0.1.0";
+	} catch {
+		return JSON.parse(readFileSync(join(_dir, "..", "..", "package.json"), "utf8")).version ?? "0.1.0";
+	}
+}
+/** Single source of truth: must match package.json version. */
+const BRIDGE_VERSION = readVersion();
+/** Manifest schema version (semantic; must match parser). */
+const BRIDGE_MANIFEST_VERSION = "1.0";
+/** Provider identifier for LeanIX (single source of truth for external.leanix). */
+const LEANIX_PROVIDER = "leanix";
+/** Fallback when element kind is unknown (G25: named constant). */
+const FALLBACK_FACT_SHEET_TYPE = "Application";
+/** Fallback when relation kind is unknown (G25: named constant). */
+const FALLBACK_RELATION_TYPE = "depends on";
+/** Default mapping: actor → Provider; override factSheetTypes/relationTypes as needed */
+const DEFAULT_LEANIX_MAPPING = {
+	factSheetTypes: {
+		system: "Application",
+		container: "ITComponent",
+		component: "ITComponent",
+		actor: "Provider"
+	},
+	relationTypes: { default: FALLBACK_RELATION_TYPE },
+	metadataToFields: {
+		title: "name",
+		description: "description",
+		technology: "technology"
+	}
+};
+/**
+* Merges partial mapping config with DEFAULT_LEANIX_MAPPING; returns a full Required<LeanixMappingConfig>.
+*/
+function mergeWithDefault(partial) {
+	const base = {
+		factSheetTypes: { ...DEFAULT_LEANIX_MAPPING.factSheetTypes },
+		relationTypes: { ...DEFAULT_LEANIX_MAPPING.relationTypes },
+		metadataToFields: { ...DEFAULT_LEANIX_MAPPING.metadataToFields }
+	};
+	if (!partial) return base;
+	return {
+		factSheetTypes: {
+			...base.factSheetTypes,
+			...partial.factSheetTypes
+		},
+		relationTypes: {
+			...base.relationTypes,
+			...partial.relationTypes
+		},
+		metadataToFields: {
+			...base.metadataToFields,
+			...partial.metadataToFields
+		}
+	};
+}
+/**
+* Returns LeanIX fact sheet type for a LikeC4 element kind.
+* Uses mapping.factSheetTypes[kind], then 'default', then FALLBACK_FACT_SHEET_TYPE.
+*/
+function getFactSheetType(likec4Kind, mapping) {
+	return mapping.factSheetTypes[likec4Kind] ?? mapping.factSheetTypes["default"] ?? FALLBACK_FACT_SHEET_TYPE;
+}
+/**
+* Returns LeanIX relation type for a LikeC4 relationship kind.
+* Uses mapping.relationTypes[kind], then 'default', then FALLBACK_RELATION_TYPE.
+*/
+function getRelationType(likec4Kind, mapping) {
+	const kind = likec4Kind ?? "default";
+	return mapping.relationTypes[kind] ?? mapping.relationTypes["default"] ?? FALLBACK_RELATION_TYPE;
+}
+const defaultOptions = {
+	manifestVersion: BRIDGE_MANIFEST_VERSION,
+	bridgeVersion: BRIDGE_VERSION,
+	mappingProfile: "default"
+};
+/** Builds manifest entities map from model elements (canonicalId + empty external). */
+function buildManifestEntities(model) {
+	const entities = {};
+	for (const el of model.elements()) entities[el.id] = {
+		canonicalId: el.id,
+		external: {}
+	};
+	return entities;
+}
+/** Builds manifest views map from model views (viewId + empty external). */
+function buildManifestViews(model) {
+	const views = {};
+	for (const v of model.views()) views[v.id] = {
+		viewId: v.id,
+		external: {}
+	};
+	return views;
+}
+/** Builds manifest relations array from model relationships (compositeKey + empty external). */
+function buildManifestRelations(model) {
+	const relations = [];
+	for (const rel of model.relationships()) relations.push({
+		relationId: rel.id,
+		sourceFqn: rel.source.id,
+		targetFqn: rel.target.id,
+		compositeKey: `${rel.source.id}|${rel.target.id}|${rel.id}`,
+		external: {}
+	});
+	return relations;
+}
+/**
+* Produces the identity manifest from a LikeC4 model (canonical IDs + placeholders for external IDs).
+* Pure function; no live API calls.
+*/
+function toBridgeManifest(model, options = {}) {
+	const opts = {
+		...defaultOptions,
+		...options,
+		generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return {
+		manifestVersion: opts.manifestVersion,
+		generatedAt: opts.generatedAt,
+		bridgeVersion: opts.bridgeVersion,
+		mappingProfile: opts.mappingProfile,
+		projectId: model.projectId,
+		entities: buildManifestEntities(model),
+		views: buildManifestViews(model),
+		relations: buildManifestRelations(model)
+	};
+}
+/** Builds LeanIX fact sheet dry-run list from model elements and mapping. */
+function buildFactSheetsFromModel(model, mapping) {
+	const factSheets = [];
+	for (const el of model.elements()) {
+		const fsType = getFactSheetType(el.kind, mapping);
+		const meta = el.getMetadata();
+		const desc = typeof meta["description"] === "string" ? meta["description"] : void 0;
+		const tech = el.technology ?? (typeof meta["technology"] === "string" ? meta["technology"] : void 0);
+		factSheets.push({
+			type: fsType,
+			likec4Id: el.id,
+			name: el.title,
+			...desc !== void 0 && { description: desc },
+			...tech !== void 0 && { technology: tech },
+			...el.tags.length > 0 && { tags: [...el.tags] },
+			...Object.keys(meta).length > 0 && { metadata: { ...meta } }
+		});
+	}
+	factSheets.sort((a, b) => a.likec4Id.localeCompare(b.likec4Id));
+	return factSheets;
+}
+/** Builds LeanIX relation dry-run list from model relationships and mapping. */
+function buildRelationsFromModel(model, mapping) {
+	const relations = [];
+	for (const rel of model.relationships()) {
+		const titleVal = rel.title ?? rel.kind;
+		relations.push({
+			type: getRelationType(rel.kind, mapping),
+			likec4RelationId: rel.id,
+			sourceLikec4Id: rel.source.id,
+			targetLikec4Id: rel.target.id,
+			...titleVal != null && titleVal !== "" && { title: String(titleVal) }
+		});
+	}
+	relations.sort((a, b) => a.likec4RelationId.localeCompare(b.likec4RelationId));
+	return relations;
+}
+/**
+* Produces LeanIX-shaped inventory artifacts (fact sheets + relations) from a LikeC4 model.
+* Pure function; no live API. Use for dry-run and planning.
+*/
+function toLeanixInventoryDryRun(model, options = {}) {
+	const mapping = mergeWithDefault(options.mapping);
+	const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const mappingProfile = options.mappingProfile ?? (options.mapping ? "custom" : "default");
+	return {
+		generatedAt,
+		projectId: model.projectId,
+		mappingProfile,
+		factSheets: buildFactSheetsFromModel(model, mapping),
+		relations: buildRelationsFromModel(model, mapping)
+	};
+}
+/** Builds error message listing which coherence fields mismatched (projectId, mappingProfile). */
+function buildCoherenceErrorMessage(manifest, leanixDryRun) {
+	const mismatches = [];
+	if (manifest.projectId !== leanixDryRun.projectId) mismatches.push(`projectId (manifest: ${manifest.projectId}, leanixDryRun: ${leanixDryRun.projectId})`);
+	if (manifest.mappingProfile !== leanixDryRun.mappingProfile) mismatches.push(`mappingProfile (manifest: ${manifest.mappingProfile}, leanixDryRun: ${leanixDryRun.mappingProfile})`);
+	return `Manifest and LeanIX dry-run must belong to the same run. Mismatch: ${mismatches.join("; ")}`;
+}
+/**
+* Builds a summary report (counts, artifact names) from manifest and dry-run. Throws if projectId or mappingProfile differ.
+*/
+function buildBridgeReport(manifest, leanixDryRun) {
+	if (manifest.projectId !== leanixDryRun.projectId || manifest.mappingProfile !== leanixDryRun.mappingProfile) throw new Error(buildCoherenceErrorMessage(manifest, leanixDryRun));
+	return {
+		generatedAt: manifest.generatedAt,
+		projectId: manifest.projectId,
+		manifestVersion: manifest.manifestVersion,
+		bridgeVersion: manifest.bridgeVersion,
+		mappingProfile: manifest.mappingProfile,
+		counts: {
+			entities: Object.keys(manifest.entities).length,
+			views: Object.keys(manifest.views).length,
+			relations: manifest.relations.length,
+			factSheets: leanixDryRun.factSheets.length,
+			leanixRelations: leanixDryRun.relations.length
+		},
+		artifacts: {
+			manifest: "manifest.json",
+			leanixDryRun: "leanix-dry-run.json"
+		}
+	};
+}
+const DEFAULT_BASE_URL = "https://app.leanix.net";
+const DEFAULT_DELAY_MS = 200;
+/** Thrown when the LeanIX API returns errors or non-OK HTTP. */
+var LeanixApiError = class extends Error {
+	constructor(message, statusCode, graphqlErrors) {
+		super(message);
+		this.statusCode = statusCode;
+		this.graphqlErrors = graphqlErrors;
+		this.name = "LeanixApiError";
+	}
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* LeanIX GraphQL API client with Bearer auth and optional rate limiting.
+* Throttle state is per instance so multiple clients do not share delay.
+*/
+var LeanixApiClient = class {
+	baseUrl;
+	apiToken;
+	requestDelayMs;
+	/** Last request timestamp for throttling (per instance). */
+	lastRequestTime = 0;
+	/** Serializes rate-limit and request so only one caller runs at a time. */
+	rateLimitLock = Promise.resolve();
+	constructor(config) {
+		this.apiToken = config.apiToken;
+		this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+		this.requestDelayMs = config.requestDelayMs ?? DEFAULT_DELAY_MS;
+	}
+	/**
+	* Execute a GraphQL operation (query or mutation).
+	* Throttles requests by requestDelayMs. Throws LeanixApiError on HTTP or GraphQL errors.
+	*/
+	async graphql(query, variables) {
+		const run = async () => {
+			const elapsed = Date.now() - this.lastRequestTime;
+			if (elapsed < this.requestDelayMs) await sleep(this.requestDelayMs - elapsed);
+			this.lastRequestTime = Date.now();
+			const url = `${this.baseUrl}/services/pathfinder/v1/graphql`;
+			let res;
+			try {
+				res = await fetch(url, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${this.apiToken}`
+					},
+					body: JSON.stringify({
+						query,
+						variables
+					})
+				});
+			} catch (err) {
+				throw new LeanixApiError(`GraphQL request failed: ${url} POST - ${err instanceof Error ? err.message : String(err)}`);
+			}
+			let body;
+			try {
+				body = await res.json();
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new LeanixApiError(`Invalid JSON response: ${url} ${res.status} ${res.statusText} - ${msg}`, res.status);
+			}
+			if (!res.ok) throw new LeanixApiError(body.errors?.[0]?.message ?? `HTTP ${res.status} ${res.statusText}`, res.status, body.errors);
+			if (body.errors && body.errors.length > 0) throw new LeanixApiError(body.errors.map((e) => e.message).join("; "), res.status, body.errors);
+			if (body.data === void 0) throw new LeanixApiError("GraphQL response had no data and no errors");
+			return body.data;
+		};
+		const prev = this.rateLimitLock;
+		let resolve;
+		this.rateLimitLock = new Promise((r) => {
+			resolve = r;
+		});
+		await prev;
+		try {
+			return await run();
+		} finally {
+			resolve();
+		}
+	}
+};
+/** Search fact sheets by name and type (for idempotency). Returns null when not found; throws on API/network error. */
+async function findFactSheetByNameAndType(client, name, type) {
+	const edges = (await client.graphql(`
+    query FindFactSheet($name: String!, $type: String!) {
+      allFactSheets(filter: { name: $name, factSheetType: $type }) {
+        edges { node { id name type } }
+      }
+    }
+  `, {
+		name,
+		type
+	})).allFactSheets?.edges ?? [];
+	if (edges.length > 1) throw new Error(`Multiple fact sheets found for name="${name}" type="${type}". Ensure unique name+type in LeanIX or use likec4Id attribute for lookup.`);
+	return (edges[0]?.node)?.id ?? null;
+}
+/**
+* Search fact sheets by custom attribute (e.g. likec4Id) for idempotent lookup.
+* Returns null when not found; throws on API/network error.
+*/
+async function findFactSheetByLikec4IdAttribute(client, attributeKey, likec4Id) {
+	const query = `
+    query FindFactSheetByAttribute($filter: FilterInput!) {
+      allFactSheets(filter: $filter) {
+        edges { node { id } }
+      }
+    }
+  `;
+	const filter = { facetFilters: [{
+		facetKey: attributeKey,
+		operator: "OR",
+		keys: [likec4Id]
+	}] };
+	const edges = (await client.graphql(query, { filter })).allFactSheets?.edges ?? [];
+	if (edges.length > 1) throw new Error(`Multiple fact sheets found for attribute ${attributeKey}=${likec4Id}. Ensure unique likec4Id in LeanIX.`);
+	return (edges[0]?.node)?.id ?? null;
+}
+/** Patch an existing fact sheet to set a custom attribute (e.g. likec4Id). Throws on API error. */
+async function patchFactSheetAttribute(client, factSheetId, attributeKey, value) {
+	const patches = [{
+		op: "replace",
+		path: `/factSheetAttributes/${attributeKey}`,
+		value
+	}];
+	if (!(await client.graphql(`
+    mutation UpdateFactSheet($id: ID!, $patches: [Patch]) {
+      updateFactSheet(id: $id, patches: $patches) {
+        factSheet { id }
+      }
+    }
+  `, {
+		id: factSheetId,
+		patches
+	})).updateFactSheet?.factSheet?.id) throw new Error(`updateFactSheet did not return fact sheet (id=${factSheetId}, attribute=${attributeKey})`);
+}
+/** Create fact sheet (name, type, optional description and likec4Id attribute). Returns new id; throws on API error. */
+async function createFactSheet(client, fs, likec4IdAttribute) {
+	const patches = [];
+	if (fs.description) patches.push({
+		op: "replace",
+		path: "/description",
+		value: fs.description
+	});
+	if (likec4IdAttribute && fs.likec4Id) patches.push({
+		op: "replace",
+		path: `/factSheetAttributes/${likec4IdAttribute}`,
+		value: fs.likec4Id
+	});
+	const mutation = `
+    mutation CreateFactSheet($input: CreateFactSheetInput!, $patches: [Patch]) {
+      createFactSheet(input: $input, patches: $patches) {
+        factSheet { id name type rev }
+      }
+    }
+  `;
+	const variables = {
+		input: {
+			name: fs.name,
+			type: fs.type
+		},
+		patches
+	};
+	const id = (await client.graphql(mutation, variables)).createFactSheet?.factSheet?.id;
+	if (!id) throw new Error(`createFactSheet did not return id for ${String(fs.name)}`);
+	return id;
+}
+/** Create a relation between two fact sheets. Returns relation id; throws when mutation returns no id. */
+async function createRelation(client, sourceFactSheetId, targetFactSheetId, relationType, _title) {
+	const data = await client.graphql(`
+    mutation CreateRelation($source: ID!, $target: ID!, $type: String!) {
+      createRelation(source: $source, target: $target, type: $type) {
+        relation { id }
+      }
+    }
+  `, {
+		source: sourceFactSheetId,
+		target: targetFactSheetId,
+		type: relationType
+	});
+	const id = data.createRelation?.relation?.id;
+	if (!id) {
+		const payload = JSON.stringify(data, null, 2);
+		throw new Error(`createRelation did not return relation id (sourceFactSheetId=${sourceFactSheetId}, targetFactSheetId=${targetFactSheetId}, relationType=${relationType}). Response: ${payload}`);
+	}
+	return id;
+}
+/**
+* Sync bridge manifest + LeanIX dry-run inventory to the LeanIX API.
+* Creates or updates fact sheets and relations; returns manifest with external LeanIX IDs.
+* Supports a read-only "plan" step that queries LeanIX to produce a sync plan artifact (Phase 2).
+*/
+function buildFactSheetPlanEntry(fs, existingFactSheetId) {
+	const action = existingFactSheetId ? "update" : "create";
+	return {
+		likec4Id: fs.likec4Id,
+		name: fs.name,
+		type: fs.type,
+		action,
+		...existingFactSheetId ? { existingFactSheetId } : {}
+	};
+}
+function buildPlanSummary(factSheetPlans, relationPlans) {
+	return {
+		factSheetsToCreate: factSheetPlans.filter((p) => p.action === "create").length,
+		factSheetsToUpdate: factSheetPlans.filter((p) => p.action === "update").length,
+		relationsToCreate: relationPlans.length
+	};
+}
+/** Normalise caught value to a string for error reporting (Clean Code: context in errors). */
+function toErrorMessage(err) {
+	if (err instanceof Error) return err.stack ? `${err.message}\n${err.stack}` : err.message;
+	if (typeof err === "object" && err !== null) try {
+		return JSON.stringify(err, null, 2);
+	} catch {
+		return Object.prototype.toString.call(err);
+	}
+	return String(err);
+}
+/** Applies LeanIX fact sheet IDs to manifest entities; returns new entities object. */
+function applyLeanixIdsToEntities(entities, likec4IdToFactSheetId) {
+	const out = { ...entities };
+	for (const [canonicalId, entity] of Object.entries(entities)) {
+		const leanixId = likec4IdToFactSheetId.get(canonicalId);
+		if (leanixId) out[canonicalId] = {
+			...entity,
+			external: {
+				...entity.external,
+				[LEANIX_PROVIDER]: {
+					factSheetId: leanixId,
+					externalId: leanixId
+				}
+			}
+		};
+	}
+	return out;
+}
+/** Resolves existing LeanIX fact sheet id by likec4Id attribute or name+type; optionally patches likec4Id. Returns null when not found. */
+async function resolveExistingFactSheetId(client, fs, idempotent, likec4IdAttribute) {
+	if (!idempotent) return null;
+	if (likec4IdAttribute) {
+		const byAttr = await findFactSheetByLikec4IdAttribute(client, likec4IdAttribute, fs.likec4Id);
+		if (byAttr) return byAttr;
+		const byNameType = await findFactSheetByNameAndType(client, fs.name, fs.type);
+		if (byNameType && fs.likec4Id) try {
+			await patchFactSheetAttribute(client, byNameType, likec4IdAttribute, fs.likec4Id);
+		} catch (err) {
+			console.warn(`[leanix-bridge] Failed to backfill likec4Id on fact sheet ${byNameType} (${fs.name}/${fs.type}): ${err instanceof Error ? err.message : String(err)}. Reusing ID.`);
+		}
+		return byNameType ?? null;
+	}
+	return findFactSheetByNameAndType(client, fs.name, fs.type);
+}
+/** Creates or finds fact sheets in LeanIX; returns map and counts. Single responsibility. */
+async function syncFactSheetsToLeanix(client, factSheets, idempotent, likec4IdAttribute) {
+	const likec4IdToFactSheetId = /* @__PURE__ */ new Map();
+	const errors = [];
+	let factSheetsCreated = 0;
+	let factSheetsReused = 0;
+	for (const fs of factSheets) try {
+		let factSheetId = await resolveExistingFactSheetId(client, fs, idempotent, likec4IdAttribute);
+		if (factSheetId) factSheetsReused++;
+		if (!factSheetId) {
+			factSheetId = await createFactSheet(client, fs, likec4IdAttribute);
+			factSheetsCreated++;
+		}
+		if (factSheetId) likec4IdToFactSheetId.set(fs.likec4Id, factSheetId);
+	} catch (e) {
+		errors.push(`Fact sheet ${fs.likec4Id} (${String(fs.name)}): ${toErrorMessage(e)}`);
+	}
+	return {
+		likec4IdToFactSheetId,
+		factSheetsCreated,
+		factSheetsReused,
+		errors
+	};
+}
+/** Creates relations in LeanIX and returns manifest relations with external IDs. Single responsibility. */
+async function syncRelationsToLeanix(client, manifestRelations, leanixRelations, likec4IdToFactSheetId) {
+	const updatedRelations = [];
+	const errors = [];
+	let relationsCreated = 0;
+	for (const rel of manifestRelations) {
+		const sourceId = likec4IdToFactSheetId.get(rel.sourceFqn);
+		const targetId = likec4IdToFactSheetId.get(rel.targetFqn);
+		const existing = rel.external?.[LEANIX_PROVIDER];
+		if (sourceId && targetId && !existing?.relationId) {
+			const dryRel = leanixRelations.find((r) => r.sourceLikec4Id === rel.sourceFqn && r.targetLikec4Id === rel.targetFqn && r.likec4RelationId === rel.relationId);
+			if (dryRel) try {
+				const relationId = await createRelation(client, sourceId, targetId, dryRel.type, dryRel.title);
+				relationsCreated++;
+				updatedRelations.push({
+					...rel,
+					external: {
+						...rel.external,
+						[LEANIX_PROVIDER]: {
+							relationId,
+							...rel.external?.[LEANIX_PROVIDER]
+						}
+					}
+				});
+				continue;
+			} catch (e) {
+				errors.push(`Relation ${rel.compositeKey}: ${toErrorMessage(e)}`);
+			}
+		}
+		updatedRelations.push(rel);
+	}
+	return {
+		updatedRelations,
+		relationsCreated,
+		errors
+	};
+}
+/**
+* Produces a sync plan by querying LeanIX for existing fact sheets (read-only; no creates/updates).
+* Use before syncToLeanix to review what would be created vs updated. Phase 2 dry-run sync planning.
+*/
+async function planSyncToLeanix(leanixDryRun, client, options = {}) {
+	const idempotent = options.idempotent ?? true;
+	const likec4IdAttribute = options.likec4IdAttribute;
+	const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const errors = [];
+	const factSheetPlans = [];
+	for (const fs of leanixDryRun.factSheets) try {
+		let existingId = null;
+		if (idempotent) if (likec4IdAttribute) {
+			existingId = await findFactSheetByLikec4IdAttribute(client, likec4IdAttribute, fs.likec4Id);
+			if (!existingId) existingId = await findFactSheetByNameAndType(client, fs.name, fs.type);
+		} else existingId = await findFactSheetByNameAndType(client, fs.name, fs.type);
+		factSheetPlans.push(buildFactSheetPlanEntry(fs, existingId));
+	} catch (e) {
+		errors.push(`Fact sheet ${fs.likec4Id} (${String(fs.name)}): ${toErrorMessage(e)}`);
+		factSheetPlans.push(buildFactSheetPlanEntry(fs, null));
+	}
+	const relationPlans = leanixDryRun.relations.map((rel) => ({
+		likec4RelationId: rel.likec4RelationId,
+		sourceLikec4Id: rel.sourceLikec4Id,
+		targetLikec4Id: rel.targetLikec4Id,
+		type: rel.type,
+		action: "create"
+	}));
+	return {
+		generatedAt,
+		projectId: leanixDryRun.projectId,
+		mappingProfile: leanixDryRun.mappingProfile,
+		summary: buildPlanSummary(factSheetPlans, relationPlans),
+		factSheetPlans,
+		relationPlans,
+		errors
+	};
+}
+/**
+* Syncs the dry-run inventory to LeanIX: creates or finds fact sheets, creates relations,
+* and returns an updated manifest with external LeanIX IDs.
+*/
+async function syncToLeanix(manifest, leanixDryRun, client, options = {}) {
+	const idempotent = options.idempotent ?? true;
+	const likec4IdAttribute = options.likec4IdAttribute;
+	const fsResult = await syncFactSheetsToLeanix(client, leanixDryRun.factSheets, idempotent, likec4IdAttribute);
+	const updatedEntities = applyLeanixIdsToEntities(manifest.entities, fsResult.likec4IdToFactSheetId);
+	const relResult = await syncRelationsToLeanix(client, manifest.relations, leanixDryRun.relations, fsResult.likec4IdToFactSheetId);
+	return {
+		manifest: {
+			...manifest,
+			entities: updatedEntities,
+			relations: relResult.updatedRelations
+		},
+		factSheetsCreated: fsResult.factSheetsCreated,
+		factSheetsReused: fsResult.factSheetsReused,
+		relationsCreated: relResult.relationsCreated,
+		errors: [...fsResult.errors, ...relResult.errors]
+	};
+}
+/**
+* Draw.io ↔ LeanIX round-trip: mapping between bridge manifest (with LeanIX external IDs)
+* and diagram identity (likec4Id, likec4RelationId).
+* Use after syncToLeanix to get a mapping for re-export or for annotating diagrams.
+*/
+/**
+* Collects likec4Id → LeanIX identity (factSheetId or externalId) from manifest entities that have LeanIX external.
+* Single responsibility: one level of abstraction for entity extraction.
+*/
+function collectLikec4IdToLeanixId(manifest) {
+	const out = {};
+	for (const [canonicalId, entity] of Object.entries(manifest.entities)) {
+		const leanixId = entity.external?.[LEANIX_PROVIDER]?.factSheetId ?? entity.external?.[LEANIX_PROVIDER]?.externalId;
+		if (leanixId) out[canonicalId] = leanixId;
+	}
+	return out;
+}
+/**
+* Collects compositeKey → LeanIX relationId from manifest relations that have LeanIX external.
+* Single responsibility: one level of abstraction for relation extraction.
+*/
+function collectRelationKeyToLeanixRelationId(manifest) {
+	const out = {};
+	for (const rel of manifest.relations) {
+		const leanixRelId = rel.external?.[LEANIX_PROVIDER]?.relationId;
+		if (leanixRelId) out[rel.compositeKey] = leanixRelId;
+	}
+	return out;
+}
+/**
+* Builds a mapping from manifest (after sync) for use in Draw.io bridge-managed export
+* or when re-importing from LeanIX. Elements can store leanixFactSheetId in style for round-trip.
+*/
+function manifestToDrawioLeanixMapping(manifest) {
+	return {
+		likec4IdToLeanixId: collectLikec4IdToLeanixId(manifest),
+		relationKeyToLeanixRelationId: collectRelationKeyToLeanixRelationId(manifest)
+	};
+}
+const DEFAULT_PAGE_SIZE = 100;
+const DEFAULT_MAX_FACT_SHEETS = 1e3;
+const MAX_GRAPHQL_RETRIES = 3;
+async function withGraphQLRetry(fn) {
+	let lastErr;
+	for (let attempt = 0; attempt < MAX_GRAPHQL_RETRIES; attempt++) try {
+		return await fn();
+	} catch (err) {
+		lastErr = err;
+		if (attempt < MAX_GRAPHQL_RETRIES - 1) await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+	}
+	throw lastErr;
+}
+/**
+* Fetches a read-only snapshot of the LeanIX inventory (fact sheets, then relations).
+* Uses cursor-based pagination. Does not modify LeanIX.
+*/
+async function fetchLeanixInventorySnapshot(client, options = {}) {
+	const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const maxFactSheets = options.maxFactSheets ?? DEFAULT_MAX_FACT_SHEETS;
+	if (!Number.isInteger(maxFactSheets) || maxFactSheets < 0) throw new Error("maxFactSheets must be a non-negative integer");
+	const likec4IdAttribute = options.likec4IdAttribute;
+	const factSheets = await fetchAllFactSheets(client, {
+		...likec4IdAttribute != null ? { likec4IdAttribute } : {},
+		maxFactSheets
+	});
+	return {
+		generatedAt,
+		factSheets,
+		relations: await fetchAllRelations(client, factSheets.map((f) => f.id))
+	};
+}
+/** Maps a GraphQL node to LeanixFactSheetSnapshotItem; returns null when node has no id. */
+function mapNodeToFactSheetItem(node, likec4IdAttribute) {
+	if (!node?.id) return null;
+	const likec4Id = likec4IdAttribute != null && Array.isArray(node.factSheetAttributes) ? node.factSheetAttributes.find((a) => a.key === likec4IdAttribute)?.value : void 0;
+	return {
+		id: node.id,
+		name: node.name ?? "",
+		type: node.type ?? "",
+		...likec4Id ? { likec4Id } : {}
+	};
+}
+async function fetchAllFactSheets(client, opts) {
+	const likec4IdAttribute = opts.likec4IdAttribute;
+	const pageSize = Math.min(DEFAULT_PAGE_SIZE, opts.maxFactSheets);
+	const result = [];
+	let after = null;
+	let hasNextPage = true;
+	const query = `
+    query AllFactSheets($first: Int!, $after: String, $filter: FilterInput) {
+      allFactSheets(first: $first, after: $after, filter: $filter) {
+        edges {
+          node {
+            id
+            name
+            type
+            ${likec4IdAttribute != null ? `factSheetAttributes { key value }` : ""}
+          }
+          cursor
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `;
+	const fetchPage = async (cursor) => withGraphQLRetry(() => client.graphql(query, {
+		first: pageSize,
+		after: cursor,
+		filter: {}
+	}));
+	while (hasNextPage && result.length < opts.maxFactSheets) {
+		const data = await fetchPage(after);
+		const edges = data.allFactSheets?.edges ?? [];
+		const pageInfo = data.allFactSheets?.pageInfo;
+		for (const edge of edges) {
+			if (result.length >= opts.maxFactSheets) break;
+			const item = mapNodeToFactSheetItem(edge.node, likec4IdAttribute);
+			if (item) result.push(item);
+		}
+		hasNextPage = pageInfo?.hasNextPage === true && result.length < opts.maxFactSheets;
+		after = pageInfo?.endCursor ?? null;
+	}
+	return result;
+}
+const RELATIONS_FETCH_CONCURRENCY = 10;
+const RELATIONS_PAGE_SIZE = 100;
+async function fetchAllRelations(client, factSheetIds) {
+	if (factSheetIds.length === 0) return [];
+	const relations = [];
+	const idSet = new Set(factSheetIds);
+	const query = `
+    query FactSheetRelations($id: ID!, $first: Int, $after: String) {
+      factSheet(id: $id) {
+        id
+        relations(first: $first, after: $after) {
+          edges {
+            node {
+              id
+              type
+              targetFactSheet { id }
+            }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  `;
+	async function fetchRelationsForFactSheet(sourceId) {
+		const out = [];
+		let after = null;
+		let hasNextPage = true;
+		while (hasNextPage) {
+			const data = await withGraphQLRetry(() => client.graphql(query, {
+				id: sourceId,
+				first: RELATIONS_PAGE_SIZE,
+				after
+			}));
+			const edges = data?.factSheet?.relations?.edges ?? [];
+			const pageInfo = data?.factSheet?.relations?.pageInfo;
+			for (const edge of edges) {
+				const node = edge.node;
+				const targetId = node?.targetFactSheet?.id;
+				if (!targetId || !idSet.has(targetId)) continue;
+				out.push({
+					...node?.id ? { id: node.id } : {},
+					sourceFactSheetId: sourceId,
+					targetFactSheetId: targetId,
+					type: node?.type ?? "RELATES_TO"
+				});
+			}
+			hasNextPage = pageInfo?.hasNextPage === true;
+			after = pageInfo?.endCursor ?? null;
+		}
+		return out;
+	}
+	for (let i = 0; i < factSheetIds.length; i += RELATIONS_FETCH_CONCURRENCY) {
+		const batch = factSheetIds.slice(i, i + RELATIONS_FETCH_CONCURRENCY);
+		const results = await Promise.all(batch.map((sourceId) => fetchRelationsForFactSheet(sourceId)));
+		for (const items of results) relations.push(...items);
+	}
+	return relations;
+}
+/**
+* Reconciliation of LeanIX inventory snapshot with LikeC4 manifest.
+* Produces matched, unmatched (in LikeC4 only / in LeanIX only), and ambiguous pairs.
+* No DSL generation; read-only comparison.
+*/
+/** Separator for name+type composite key (G25: avoid magic character). */
+const NAME_TYPE_SEP = "\0";
+/** Tries to match by manifest entity's external.leanix.factSheetId; returns match or null. */
+function tryMatchByManifestFactSheetId(entity, canonicalId, snapshotById, usedFactSheetIds) {
+	const leanixExternal = entity.external?.[LEANIX_PROVIDER];
+	const manifestFactSheetId = leanixExternal?.factSheetId ?? leanixExternal?.externalId;
+	if (manifestFactSheetId == null) return null;
+	const fs = snapshotById.get(manifestFactSheetId);
+	if (!fs) return null;
+	if (usedFactSheetIds.has(fs.id)) return null;
+	usedFactSheetIds.add(fs.id);
+	return {
+		canonicalId,
+		factSheetId: fs.id,
+		name: fs.name,
+		type: fs.type
+	};
+}
+/** Tries to match by snapshot fact sheet's likec4Id === canonicalId; returns match or null. */
+function tryMatchByLikec4Id(canonicalId, snapshotByLikec4Id, usedFactSheetIds) {
+	const byLikec4 = snapshotByLikec4Id.get(canonicalId);
+	if (!byLikec4 || usedFactSheetIds.has(byLikec4.id)) return null;
+	usedFactSheetIds.add(byLikec4.id);
+	return {
+		canonicalId,
+		factSheetId: byLikec4.id,
+		name: byLikec4.name,
+		type: byLikec4.type
+	};
+}
+/** Resolves match by name+type (or pushes to unmatchedInLikec4 / ambiguous). */
+function resolveByNameAndType(canonicalId, entityName, entityType, snapshotByNameAndType, usedFactSheetIds, matched, unmatchedInLikec4, ambiguous) {
+	const nameTypeKey = `${entityName ?? canonicalId}${NAME_TYPE_SEP}${entityType ?? ""}`;
+	const candidates = snapshotByNameAndType.get(nameTypeKey)?.filter((f) => !usedFactSheetIds.has(f.id)) ?? [];
+	if (candidates.length === 0) unmatchedInLikec4.push({
+		canonicalId,
+		...entityName !== void 0 ? { name: entityName } : {},
+		...entityType !== void 0 ? { type: entityType } : {}
+	});
+	else if (candidates.length === 1) {
+		const candidate = candidates[0];
+		matched.push({
+			canonicalId,
+			factSheetId: candidate.id,
+			name: candidate.name,
+			type: candidate.type
+		});
+		usedFactSheetIds.add(candidate.id);
+	} else ambiguous.push({
+		canonicalId,
+		...entityName !== void 0 ? { name: entityName } : {},
+		...entityType !== void 0 ? { type: entityType } : {},
+		candidateFactSheetIds: candidates.map((c) => c.id)
+	});
+}
+/**
+* Reconciles a LeanIX inventory snapshot with the bridge manifest.
+* Matching order: 1) manifest entity has external.leanix.factSheetId; 2) snapshot fact sheet has likec4Id === canonicalId; 3) if dryRun provided, name+type (can be ambiguous).
+* Does not modify any data; no DSL generation.
+*/
+function reconcileInventoryWithManifest(snapshot, manifest, options = {}) {
+	const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const dryRun = options.dryRun;
+	const matched = [];
+	const unmatchedInLikec4 = [];
+	const ambiguous = [];
+	const snapshotById = new Map(snapshot.factSheets.map((f) => [f.id, f]));
+	const snapshotByLikec4Id = /* @__PURE__ */ new Map();
+	const snapshotByNameAndType = /* @__PURE__ */ new Map();
+	for (const fs of snapshot.factSheets) {
+		if (fs.likec4Id) snapshotByLikec4Id.set(fs.likec4Id, fs);
+		const key = `${fs.name}${NAME_TYPE_SEP}${fs.type}`;
+		if (!snapshotByNameAndType.has(key)) snapshotByNameAndType.set(key, []);
+		snapshotByNameAndType.get(key).push(fs);
+	}
+	const dryRunByCanonicalId = dryRun ? new Map(dryRun.factSheets.map((f) => [f.likec4Id, f])) : null;
+	const usedFactSheetIds = /* @__PURE__ */ new Set();
+	for (const [canonicalId, entity] of Object.entries(manifest.entities)) {
+		const byManifest = tryMatchByManifestFactSheetId(entity, canonicalId, snapshotById, usedFactSheetIds);
+		if (byManifest) {
+			matched.push(byManifest);
+			continue;
+		}
+		const byLikec4 = tryMatchByLikec4Id(canonicalId, snapshotByLikec4Id, usedFactSheetIds);
+		if (byLikec4) {
+			matched.push(byLikec4);
+			continue;
+		}
+		const dryRunFs = dryRunByCanonicalId?.get(canonicalId);
+		resolveByNameAndType(canonicalId, dryRunFs?.name ?? void 0, dryRunFs?.type ?? void 0, snapshotByNameAndType, usedFactSheetIds, matched, unmatchedInLikec4, ambiguous);
+	}
+	const unmatchedInLeanix = snapshot.factSheets.filter((f) => !usedFactSheetIds.has(f.id)).map((f) => ({
+		factSheetId: f.id,
+		name: f.name,
+		type: f.type,
+		...f.likec4Id ? { likec4Id: f.likec4Id } : {}
+	}));
+	return {
+		generatedAt,
+		manifestProjectId: manifest.projectId,
+		snapshotGeneratedAt: snapshot.generatedAt,
+		matched,
+		unmatchedInLikec4,
+		unmatchedInLeanix,
+		ambiguous,
+		summary: {
+			matched: matched.length,
+			unmatchedInLikec4: unmatchedInLikec4.length,
+			unmatchedInLeanix: unmatchedInLeanix.length,
+			ambiguous: ambiguous.length
+		}
+	};
+}
+/**
+* Builds an impact report from a sync plan (read-only).
+* Use before applying sync to understand what would be created/updated.
+*/
+function impactReportFromSyncPlan(plan) {
+	const { summary, errors } = plan;
+	const parts = [];
+	if (summary.factSheetsToCreate > 0) parts.push(`${summary.factSheetsToCreate} fact sheet(s) to create`);
+	if (summary.factSheetsToUpdate > 0) parts.push(`${summary.factSheetsToUpdate} fact sheet(s) to update`);
+	if (summary.relationsToCreate > 0) parts.push(`${summary.relationsToCreate} relation(s) to create`);
+	const impactSummary = parts.length > 0 ? parts.join("; ") : "No changes";
+	return {
+		generatedAt: plan.generatedAt,
+		projectId: plan.projectId,
+		mappingProfile: plan.mappingProfile,
+		summary,
+		impactSummary: errors.length > 0 ? `${impactSummary} (${errors.length} plan error(s))` : impactSummary,
+		hasErrors: errors.length > 0
+	};
+}
+/**
+* Builds a drift report from a reconciliation result.
+* In_sync: all matched, no unmatched, no ambiguous. Likec4_ahead: only unmatched in LikeC4. Leanix_ahead: only unmatched in LeanIX. Diverged: mixed or ambiguous.
+*/
+function buildDriftReport(reconciliation) {
+	const { summary } = reconciliation;
+	const hasUnmatchedLikec4 = summary.unmatchedInLikec4 > 0;
+	const hasUnmatchedLeanix = summary.unmatchedInLeanix > 0;
+	const hasAmbiguous = summary.ambiguous > 0;
+	let status;
+	let description;
+	switch (true) {
+		case hasAmbiguous || hasUnmatchedLikec4 && hasUnmatchedLeanix:
+			status = "diverged";
+			description = `${summary.ambiguous} ambiguous; ${summary.unmatchedInLikec4} only in LikeC4, ${summary.unmatchedInLeanix} only in LeanIX`;
+			break;
+		case hasUnmatchedLikec4 && !hasUnmatchedLeanix:
+			status = "likec4_ahead";
+			description = `${summary.unmatchedInLikec4} element(s) in LikeC4 not yet in LeanIX`;
+			break;
+		case hasUnmatchedLeanix && !hasUnmatchedLikec4:
+			status = "leanix_ahead";
+			description = `${summary.unmatchedInLeanix} fact sheet(s) in LeanIX not in LikeC4`;
+			break;
+		default:
+			status = "in_sync";
+			description = `${summary.matched} matched; no drift`;
+	}
+	return {
+		generatedAt: reconciliation.generatedAt,
+		manifestProjectId: reconciliation.manifestProjectId,
+		snapshotGeneratedAt: reconciliation.snapshotGeneratedAt,
+		status,
+		summary: reconciliation.summary,
+		description
+	};
+}
+/** Returns date part YYYY-MM-DD from ISO timestamp (G25, G5). Handles short strings defensively. */
+function formatIsoDateString(iso) {
+	if (typeof iso !== "string" || iso.length < 10) return iso;
+	return iso.slice(0, 10);
+}
+/** Shared ADR header lines (title, status, date). Reduces duplication between ADR generators. */
+function buildAdrHeader(title, status, dateIso) {
+	return [
+		`# ${title}`,
+		"",
+		`- Status: ${status}`,
+		`- Date: ${formatIsoDateString(dateIso)}`,
+		""
+	];
+}
+/**
+* Generates a short ADR-style markdown document from a reconciliation result (and optional impact).
+* Use for governance or audit trail; does not modify any data.
+*/
+function generateAdrFromReconciliation(reconciliation, options = {}) {
+	const title = options.title ?? "LeanIX inventory reconciliation";
+	const status = options.status ?? "Proposed";
+	const impact = options.impact;
+	const lines = [
+		...buildAdrHeader(title, status, reconciliation.generatedAt),
+		"## Context",
+		"",
+		`Reconciliation of LikeC4 manifest (project: ${reconciliation.manifestProjectId}) with LeanIX inventory snapshot (${formatIsoDateString(reconciliation.snapshotGeneratedAt)}).`,
+		"",
+		"## Result",
+		"",
+		`- Matched: ${reconciliation.summary.matched}`,
+		`- Unmatched in LikeC4: ${reconciliation.summary.unmatchedInLikec4}`,
+		`- Unmatched in LeanIX: ${reconciliation.summary.unmatchedInLeanix}`,
+		`- Ambiguous: ${reconciliation.summary.ambiguous}`,
+		""
+	];
+	if (impact) lines.push("## Impact (if sync applied)", "", impact.impactSummary, "", "");
+	lines.push("## Decision", "", "LikeC4 remains the single source of truth; LeanIX is an adapter. No DSL is auto-generated from LeanIX.", "");
+	return lines.join("\n");
+}
+/**
+* Generates a short ADR-style markdown from a drift report.
+*/
+function generateAdrFromDriftReport(drift, options = {}) {
+	return [
+		...buildAdrHeader(options.title ?? "LeanIX drift report", options.status ?? "Proposed", drift.generatedAt),
+		"## Drift status",
+		"",
+		drift.description,
+		"",
+		"## Summary",
+		"",
+		`- Matched: ${drift.summary.matched}`,
+		`- Unmatched in LikeC4: ${drift.summary.unmatchedInLikec4}`,
+		`- Unmatched in LeanIX: ${drift.summary.unmatchedInLeanix}`,
+		`- Ambiguous: ${drift.summary.ambiguous}`,
+		"",
+		"## Decision",
+		"",
+		"Review drift findings and determine whether synchronization or manual remediation is required.",
+		""
+	].join("\n");
+}
+const DEFAULT_OPTIONS = {
+	noAmbiguous: true,
+	allLikec4Matched: false,
+	noOrphanInLeanix: false
+};
+/** Builds a single check result (G5: reduce duplication). */
+function buildCheck(id, name, passed, failedMessage) {
+	const result = {
+		id,
+		name,
+		passed
+	};
+	if (!passed && failedMessage !== void 0) result.message = failedMessage;
+	return result;
+}
+/**
+* Runs governance checks on a reconciliation result.
+* Returns a report with one entry per check; overall passed iff all checks pass.
+*/
+function runGovernanceChecks(reconciliation, options = {}) {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const checks = [];
+	const { summary } = reconciliation;
+	if (opts.noAmbiguous) checks.push(buildCheck("noAmbiguous", "No ambiguous matches", summary.ambiguous === 0, `${summary.ambiguous} ambiguous match(es)`));
+	if (opts.allLikec4Matched) checks.push(buildCheck("allLikec4Matched", "All LikeC4 elements matched in LeanIX", summary.unmatchedInLikec4 === 0, `${summary.unmatchedInLikec4} unmatched in LikeC4`));
+	if (opts.noOrphanInLeanix) checks.push(buildCheck("noOrphanInLeanix", "No LeanIX fact sheets without LikeC4 match", summary.unmatchedInLeanix === 0, `${summary.unmatchedInLeanix} unmatched in LeanIX`));
+	return {
+		passed: checks.every((c) => c.passed),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		checks
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isManifestEntity(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["canonicalId"] === "string";
+}
+function isManifestView(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["viewId"] === "string";
+}
+function isManifestRelation(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["relationId"] === "string" && typeof value["sourceFqn"] === "string" && typeof value["targetFqn"] === "string" && typeof value["compositeKey"] === "string";
+}
+function isLeanixFactSheetSnapshotItem(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["id"] === "string" && typeof value["name"] === "string" && typeof value["type"] === "string";
+}
+function isLeanixRelationSnapshotItem(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["sourceFactSheetId"] === "string" && typeof value["targetFactSheetId"] === "string" && typeof value["type"] === "string";
+}
+/**
+* Returns true if the value is a valid BridgeManifest shape (manifestVersion, generatedAt, bridgeVersion, mappingProfile, projectId, entities, relations, views)
+* and nested entities/views/relations match expected shapes.
+*/
+function isBridgeManifest(obj) {
+	if (!isRecord(obj)) return false;
+	if (typeof obj["manifestVersion"] !== "string" || typeof obj["generatedAt"] !== "string" || typeof obj["bridgeVersion"] !== "string" || typeof obj["mappingProfile"] !== "string" || typeof obj["projectId"] !== "string") return false;
+	const entities = obj["entities"];
+	if (typeof entities !== "object" || entities === null || Array.isArray(entities)) return false;
+	for (const v of Object.values(entities)) if (!isManifestEntity(v)) return false;
+	const views = obj["views"];
+	if (typeof views !== "object" || views === null || Array.isArray(views)) return false;
+	for (const v of Object.values(views)) if (!isManifestView(v)) return false;
+	const relations = obj["relations"];
+	if (!Array.isArray(relations)) return false;
+	for (const r of relations) if (!isManifestRelation(r)) return false;
+	return true;
+}
+/**
+* Returns true if the value is a valid LeanixInventorySnapshot shape (generatedAt, factSheets and relations arrays)
+* and each fact sheet/relation item has required fields.
+*/
+function isLeanixInventorySnapshot(obj) {
+	if (!isRecord(obj)) return false;
+	if (typeof obj["generatedAt"] !== "string") return false;
+	if (obj["workspaceId"] !== void 0 && typeof obj["workspaceId"] !== "string") return false;
+	if (!Array.isArray(obj["factSheets"])) return false;
+	for (const fs of obj["factSheets"]) if (!isLeanixFactSheetSnapshotItem(fs)) return false;
+	if (!Array.isArray(obj["relations"])) return false;
+	for (const rel of obj["relations"]) if (!isLeanixRelationSnapshotItem(rel)) return false;
+	return true;
+}
+export { BRIDGE_MANIFEST_VERSION, BRIDGE_VERSION, DEFAULT_LEANIX_MAPPING, FALLBACK_FACT_SHEET_TYPE, FALLBACK_RELATION_TYPE, LEANIX_PROVIDER, LeanixApiClient, LeanixApiError, buildBridgeReport, buildDriftReport, fetchLeanixInventorySnapshot, generateAdrFromDriftReport, generateAdrFromReconciliation, getFactSheetType, getRelationType, impactReportFromSyncPlan, isBridgeManifest, isLeanixInventorySnapshot, manifestToDrawioLeanixMapping, mergeWithDefault, planSyncToLeanix, reconcileInventoryWithManifest, runGovernanceChecks, syncToLeanix, toBridgeManifest, toLeanixInventoryDryRun };