@uigraph/sdk 1.1.34

package/dist/index.mjs

@@ -0,0 +1,4589 @@
+import { t as ComponentInputType } from "./__component-type.CYmD-KIu.mjs";
+import { t as contextSchema } from "./__headless.CP3up7Jj.mjs";
+import { arrayNonNullable, generateUUID as generateUUID$1, objectPick } from "daily-code";
+import { z } from "zod";
+import { MarkerType, Position } from "@xyflow/react";
+import dagre from "dagre";
+import mermaid from "mermaid";
+import markdownToDelta from "markdown-to-quill-delta";
+function mapDynamoTypeToAstType(dynamoType) {
+	switch (dynamoType) {
+		case "S": return "string";
+		case "N": return "number";
+		case "B": return "binary";
+		default: return "string";
+	}
+}
+function convertDynamoSchemaToAst(schema) {
+	var _schema$name;
+	const pkName = schema.primaryKey.partitionKey;
+	const pkType = schema.primaryKey.partitionKeyType;
+	const skName = schema.primaryKey.sortKey;
+	const skType = schema.primaryKey.sortKeyType;
+	const mergedAttributes = [];
+	const attributeByName = /* @__PURE__ */ new Map();
+	(schema.attributes || []).forEach((attribute) => {
+		const key = attribute.name.trim();
+		if (!key || attributeByName.has(key)) return;
+		attributeByName.set(key, attribute);
+		mergedAttributes.push(attribute);
+	});
+	const tableName = ((_schema$name = schema.name) === null || _schema$name === void 0 ? void 0 : _schema$name.trim()) || "dynamodb_table";
+	const baseColumns = [{
+		type: "column",
+		name: pkName,
+		dataType: { name: mapDynamoTypeToAstType(pkType || "string") },
+		nullable: false,
+		comment: void 0
+	}];
+	if (skName) baseColumns.push({
+		type: "column",
+		name: skName,
+		dataType: { name: mapDynamoTypeToAstType(skType || "string") },
+		nullable: false,
+		comment: void 0
+	});
+	const attributeColumns = mergedAttributes.map((attribute) => ({
+		type: "column",
+		name: attribute.name,
+		dataType: { name: attribute.type },
+		nullable: !attribute.required,
+		comment: attribute.notes
+	}));
+	const indexes = schema.globalSecondaryIndexes.map((gsi) => ({
+		type: "index",
+		name: gsi.name || "gsi",
+		columns: [{ name: gsi.partitionKey || pkName }, ...gsi.sortKey ? [{ name: gsi.sortKey }] : []],
+		unique: false
+	}));
+	return {
+		dialect: "dynamodb",
+		tables: [{
+			type: "table",
+			id: generateUUID$1(),
+			name: tableName,
+			columns: [...baseColumns, ...attributeColumns],
+			constraints: [{
+				type: "primary_key",
+				columns: skName ? [pkName, skName] : [pkName]
+			}],
+			indexes,
+			options: { comment: schema.description }
+		}],
+		metadata: { createdAt: /* @__PURE__ */ new Date() }
+	};
+}
+function convertMongoSchemaToAst(schema) {
+	return {
+		dialect: "mongodb",
+		tables: schema.collections.map((collection) => {
+			function buildColumnsFromField(field, prefix = "") {
+				const columns$1 = [];
+				const columnName = prefix ? `${prefix}.${field.name}` : field.name;
+				if (field.type === "array") {
+					const itemType = field.itemType || "string";
+					if (itemType === "object" && field.itemFields) field.itemFields.forEach((itemField) => {
+						columns$1.push(...buildColumnsFromField(itemField, `${columnName}[]`));
+					});
+					else columns$1.push({
+						type: "column",
+						name: columnName,
+						dataType: { name: `${itemType}[]` },
+						nullable: !field.required
+					});
+				} else if (field.type === "object" && field.fields) field.fields.forEach((nestedField) => {
+					columns$1.push(...buildColumnsFromField(nestedField, columnName));
+				});
+				else columns$1.push({
+					type: "column",
+					name: columnName,
+					dataType: { name: field.type },
+					nullable: !field.required
+				});
+				return columns$1;
+			}
+			const columns = collection.fields.flatMap((field) => buildColumnsFromField(field));
+			const indexes = collection.indexes.map((index) => ({
+				type: "index",
+				name: index.name || `idx_${collection.name}`,
+				columns: index.fields.map((field) => ({ name: field.fieldName })),
+				unique: index.unique
+			}));
+			return {
+				type: "table",
+				id: collection.id,
+				name: collection.name,
+				columns,
+				constraints: [],
+				indexes,
+				options: { comment: collection.description }
+			};
+		}),
+		metadata: { createdAt: /* @__PURE__ */ new Date() }
+	};
+}
+function convertJsonSchemaToAst(schema) {
+	function buildColumnFromField(field, prefix = "") {
+		const columns = [];
+		const columnName = prefix ? `${prefix}.${field.name}` : field.name;
+		if (field.type === "array") {
+			const itemType = field.itemType || "string";
+			if (itemType === "object" && field.itemFields) field.itemFields.forEach((itemField) => {
+				columns.push(...buildColumnFromField(itemField, `${columnName}[]`));
+			});
+			else columns.push({
+				type: "column",
+				name: columnName,
+				dataType: { name: `${itemType}[]` },
+				nullable: !field.required,
+				comment: "notes" in field ? field.notes : void 0
+			});
+		} else if (field.type === "object" && field.fields) field.fields.forEach((nestedField) => {
+			columns.push(...buildColumnFromField(nestedField, columnName));
+		});
+		else columns.push({
+			type: "column",
+			name: columnName,
+			dataType: { name: field.type },
+			nullable: !field.required,
+			comment: "notes" in field ? field.notes : void 0
+		});
+		return columns;
+	}
+	return {
+		dialect: "json",
+		tables: schema.collections.map((collection) => {
+			const columns = collection.fields.flatMap((field) => buildColumnFromField(field));
+			const constraints = collection.fields.filter((field) => {
+				var _field$reference;
+				return (_field$reference = field.reference) === null || _field$reference === void 0 ? void 0 : _field$reference.collectionId;
+			}).map((field) => {
+				const target = schema.collections.find((c) => {
+					var _field$reference2;
+					return c.id === ((_field$reference2 = field.reference) === null || _field$reference2 === void 0 ? void 0 : _field$reference2.collectionId);
+				});
+				const targetField = target === null || target === void 0 ? void 0 : target.fields.find((f) => {
+					var _field$reference3;
+					return f.id === ((_field$reference3 = field.reference) === null || _field$reference3 === void 0 ? void 0 : _field$reference3.fieldId);
+				});
+				return {
+					type: "foreign_key",
+					columns: [field.name],
+					referencedTable: (target === null || target === void 0 ? void 0 : target.name) || "",
+					referencedColumns: targetField ? [targetField.name] : ["id"]
+				};
+			});
+			const indexes = collection.indexes.map((index) => ({
+				type: "index",
+				name: index.name || `idx_${collection.name}`,
+				columns: index.fields.map((field) => ({ name: field })),
+				unique: index.unique,
+				where: index.ttl ? `ttl:${index.ttl}` : void 0
+			}));
+			return {
+				type: "table",
+				id: collection.id,
+				name: collection.name,
+				columns,
+				constraints,
+				indexes,
+				options: { comment: collection.description }
+			};
+		}),
+		metadata: { createdAt: /* @__PURE__ */ new Date() }
+	};
+}
+const DialectIdSchema = z.union([
+	z.literal("dynamodb"),
+	z.literal("mongodb"),
+	z.literal("json")
+]);
+const EditorSupportedDialectSchema = DialectIdSchema.or(z.literal("nosql"));
+const BasicDetailsSchema = z.object({
+	name: z.string(),
+	description: z.string().optional()
+});
+const NestedFieldSchema = z.lazy(() => z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.string(),
+	required: z.boolean(),
+	fields: z.array(NestedFieldSchema).optional(),
+	itemType: z.string().optional(),
+	itemFields: z.array(NestedFieldSchema).optional()
+}));
+const NoSqlFieldSchema = z.lazy(() => z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.string(),
+	required: z.boolean(),
+	isArray: z.boolean(),
+	reference: z.object({
+		collectionId: z.string(),
+		fieldId: z.string().optional()
+	}).optional(),
+	notes: z.string().optional(),
+	fields: z.array(NestedFieldSchema).optional(),
+	itemType: z.string().optional(),
+	itemFields: z.array(NestedFieldSchema).optional()
+}));
+const DocumentIndexSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	fields: z.array(z.string()),
+	unique: z.boolean(),
+	ttl: z.string().optional()
+});
+const DocumentCollectionSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string().optional(),
+	description: z.string().optional(),
+	tags: z.string().optional(),
+	fields: z.array(NoSqlFieldSchema),
+	indexes: z.array(DocumentIndexSchema),
+	sample: z.string().optional()
+});
+const MongoNestedFieldSchema = z.lazy(() => z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.string(),
+	required: z.boolean(),
+	fields: z.array(MongoNestedFieldSchema).optional(),
+	itemType: z.string().optional(),
+	itemFields: z.array(MongoNestedFieldSchema).optional(),
+	refCollectionId: z.string().nullable().optional()
+}));
+const MongoIndexFieldSchema = z.object({
+	id: z.string(),
+	fieldName: z.string(),
+	order: z.union([z.literal(1), z.literal(-1)])
+});
+const MongoIndexSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	fields: z.array(MongoIndexFieldSchema),
+	unique: z.boolean()
+});
+const MongoCollectionSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	tags: z.string(),
+	description: z.string(),
+	fields: z.array(MongoNestedFieldSchema),
+	indexes: z.array(MongoIndexSchema)
+});
+const DynamoGsiSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	partitionKey: z.string(),
+	partitionKeyType: z.string().optional(),
+	sortKey: z.string().optional(),
+	sortKeyType: z.string().optional()
+});
+const DynamoAttributeSchema = z.lazy(() => z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.string(),
+	required: z.boolean(),
+	notes: z.string().optional(),
+	fields: z.array(DynamoAttributeSchema).optional(),
+	itemType: z.string().optional(),
+	itemFields: z.array(DynamoAttributeSchema).optional()
+}));
+const DynamoEditorSchema = BasicDetailsSchema.extend({
+	dialect: z.literal("dynamodb"),
+	primaryKey: z.object({
+		partitionKey: z.string(),
+		partitionKeyType: z.string().optional(),
+		sortKey: z.string().optional(),
+		sortKeyType: z.string().optional()
+	}),
+	globalSecondaryIndexes: z.array(DynamoGsiSchema),
+	attributes: z.array(DynamoAttributeSchema)
+});
+const MongoEditorSchema = BasicDetailsSchema.extend({
+	dialect: z.literal("mongodb"),
+	collections: z.array(MongoCollectionSchema)
+});
+const JsonEditorSchema = BasicDetailsSchema.extend({
+	dialect: z.literal("json"),
+	collections: z.array(DocumentCollectionSchema)
+});
+function convertNoSQLToAst(input) {
+	const dynamoDbSchema = DynamoEditorSchema.safeParse(input);
+	if (dynamoDbSchema.success) return convertDynamoSchemaToAst(dynamoDbSchema.data);
+	const mongoDbSchema = MongoEditorSchema.safeParse(input);
+	if (mongoDbSchema.success) return convertMongoSchemaToAst(mongoDbSchema.data);
+	const jsonSchema = JsonEditorSchema.safeParse(input);
+	if (jsonSchema.success) return convertJsonSchemaToAst(jsonSchema.data);
+	throw new Error("Input does not match any supported NoSQL schema format");
+}
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+function createEdgeMarker(marker) {
+	if (!(marker === null || marker === void 0 ? void 0 : marker.type) || marker.type === "none") return void 0;
+	if (marker.type === MarkerType.Arrow || marker.type === MarkerType.ArrowClosed) return _objectSpread2({
+		color: "context-stroke",
+		strokeWidth: 1.5
+	}, marker);
+	return marker.type;
+}
+const DEFAULT_NODE_WIDTH = 350;
+const DEFAULT_NODE_X_OFFSET = 0;
+const DEFAULT_NODE_X_OFFSET_LAYER = 100;
+const DEFAULT_NODE_X_SPACING = 450;
+const DEFAULT_NODE_Y_OFFSET = 100;
+const DEFAULT_NODE_Y_OFFSET_LAYER = 100;
+const DEFAULT_NODE_Y_SPACING = 600;
+function computeLayeredLayout(nodes, edges, config = {}) {
+	const { horizontalSpacing = DEFAULT_NODE_X_SPACING, verticalSpacing = DEFAULT_NODE_Y_SPACING, startX = DEFAULT_NODE_X_OFFSET_LAYER, startY = DEFAULT_NODE_Y_OFFSET_LAYER } = config;
+	const { acyclicEdges, reversedEdges } = breakCycles(nodes, edges);
+	const joinTables = detectJoinTables(nodes, edges);
+	const layers = assignLayers(nodes, acyclicEdges, joinTables);
+	minimizeCrossings(layers, acyclicEdges, joinTables, 4);
+	adjacentSwapOptimization(layers, acyclicEdges);
+	positionJoinTables(nodes, layers, joinTables, acyclicEdges);
+	const positions = assignCoordinates(nodes, layers, horizontalSpacing, verticalSpacing, startX, startY);
+	balanceColumns(positions, layers);
+	return {
+		positions,
+		layers,
+		reversedEdges,
+		ports: calculatePorts(nodes)
+	};
+}
+function breakCycles(nodes, edges) {
+	const reversedEdges = /* @__PURE__ */ new Set();
+	const acyclicEdges = [];
+	const outgoing = /* @__PURE__ */ new Map();
+	const incoming = /* @__PURE__ */ new Map();
+	const edgeMap = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => {
+		outgoing.set(node.id, /* @__PURE__ */ new Set());
+		incoming.set(node.id, /* @__PURE__ */ new Set());
+	});
+	edges.forEach((edge) => {
+		var _outgoing$get, _incoming$get;
+		const key = `${edge.source}->${edge.target}`;
+		edgeMap.set(key, edge);
+		(_outgoing$get = outgoing.get(edge.source)) === null || _outgoing$get === void 0 || _outgoing$get.add(edge.target);
+		(_incoming$get = incoming.get(edge.target)) === null || _incoming$get === void 0 || _incoming$get.add(edge.source);
+	});
+	const remaining = new Set(nodes.map((n) => n.id));
+	const leftSequence = [];
+	const rightSequence = [];
+	while (remaining.size > 0) {
+		const sources = [...remaining].filter((node) => {
+			return ![...incoming.get(node) || /* @__PURE__ */ new Set()].some((src) => remaining.has(src));
+		});
+		if (sources.length > 0) {
+			sources.forEach((node) => {
+				leftSequence.push(node);
+				remaining.delete(node);
+			});
+			continue;
+		}
+		const sinks = [...remaining].filter((node) => {
+			return ![...outgoing.get(node) || /* @__PURE__ */ new Set()].some((tgt) => remaining.has(tgt));
+		});
+		if (sinks.length > 0) {
+			sinks.forEach((node) => {
+				rightSequence.unshift(node);
+				remaining.delete(node);
+			});
+			continue;
+		}
+		let maxDelta = -Infinity;
+		let maxNode = remaining.values().next().value;
+		remaining.forEach((node) => {
+			const delta = (outgoing.get(node) || /* @__PURE__ */ new Set()).size - (incoming.get(node) || /* @__PURE__ */ new Set()).size;
+			if (delta > maxDelta) {
+				maxDelta = delta;
+				maxNode = node;
+			}
+		});
+		if (maxNode) {
+			leftSequence.push(maxNode);
+			remaining.delete(maxNode);
+		}
+	}
+	const ordering = [...leftSequence, ...rightSequence];
+	const position = new Map(ordering.map((id, idx) => [id, idx]));
+	edges.forEach((edge) => {
+		if (position.get(edge.source) < position.get(edge.target)) acyclicEdges.push(edge);
+		else {
+			const key = `${edge.source}->${edge.target}`;
+			reversedEdges.add(key);
+			acyclicEdges.push(_objectSpread2(_objectSpread2({}, edge), {}, {
+				source: edge.target,
+				target: edge.source
+			}));
+		}
+	});
+	return {
+		acyclicEdges,
+		reversedEdges
+	};
+}
+function assignLayers(nodes, edges, joinTables) {
+	const layers = /* @__PURE__ */ new Map();
+	const outgoing = /* @__PURE__ */ new Map();
+	const incoming = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => {
+		outgoing.set(node.id, /* @__PURE__ */ new Set());
+		incoming.set(node.id, /* @__PURE__ */ new Set());
+	});
+	edges.forEach((edge) => {
+		var _outgoing$get2, _incoming$get2;
+		(_outgoing$get2 = outgoing.get(edge.source)) === null || _outgoing$get2 === void 0 || _outgoing$get2.add(edge.target);
+		(_incoming$get2 = incoming.get(edge.target)) === null || _incoming$get2 === void 0 || _incoming$get2.add(edge.source);
+	});
+	const hubScores = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => {
+		const outDegree = (outgoing.get(node.id) || /* @__PURE__ */ new Set()).size;
+		const inDegree = (incoming.get(node.id) || /* @__PURE__ */ new Set()).size;
+		const score = Math.max(-2, Math.min(2, outDegree - inDegree));
+		hubScores.set(node.id, score * .3);
+	});
+	const visited = /* @__PURE__ */ new Set();
+	function assignLayer(nodeId, layer) {
+		if (!layers.has(nodeId) || layers.get(nodeId) < layer) layers.set(nodeId, layer);
+		if (visited.has(nodeId)) return;
+		visited.add(nodeId);
+		(outgoing.get(nodeId) || /* @__PURE__ */ new Set()).forEach((child) => {
+			assignLayer(child, layer + 1);
+		});
+		visited.delete(nodeId);
+	}
+	const roots = nodes.filter((node) => {
+		return (incoming.get(node.id) || /* @__PURE__ */ new Set()).size === 0;
+	});
+	if (roots.length === 0) [...nodes].sort((a, b) => {
+		return (hubScores.get(b.id) || 0) - (hubScores.get(a.id) || 0);
+	}).slice(0, 3).forEach((node) => assignLayer(node.id, 0));
+	else roots.forEach((root) => assignLayer(root.id, 0));
+	nodes.forEach((node) => {
+		if (!layers.has(node.id)) layers.set(node.id, 0);
+	});
+	nodes.forEach((node) => {
+		const baseRank = layers.get(node.id);
+		const bias = hubScores.get(node.id) || 0;
+		const adjustedRank = Math.max(0, Math.round(baseRank - bias));
+		layers.set(node.id, adjustedRank);
+	});
+	joinTables.forEach((joinId) => {
+		const parents = [...incoming.get(joinId) || /* @__PURE__ */ new Set()];
+		if (parents.length >= 2) {
+			const parentRanks = parents.map((p) => layers.get(p) || 0);
+			const maxParentRank = Math.max(...parentRanks);
+			layers.set(joinId, maxParentRank + 1);
+		}
+	});
+	const layerGroups = /* @__PURE__ */ new Map();
+	layers.forEach((layer, nodeId) => {
+		if (!layerGroups.has(layer)) layerGroups.set(layer, []);
+		layerGroups.get(layer).push(nodeId);
+	});
+	return layerGroups;
+}
+function detectJoinTables(nodes, _edges) {
+	const joinTables = /* @__PURE__ */ new Set();
+	nodes.forEach((node) => {
+		const fkCount = node.columns.filter((c) => c.isForeignKey).length;
+		const nonFkCount = node.columns.filter((c) => !c.isForeignKey).length;
+		if (fkCount >= 2 && nonFkCount <= 2) joinTables.add(node.id);
+	});
+	return joinTables;
+}
+function minimizeCrossings(layers, edges, joinTables, iterations) {
+	const maxLayer = Math.max(...layers.keys());
+	const outgoing = /* @__PURE__ */ new Map();
+	const incoming = /* @__PURE__ */ new Map();
+	edges.forEach((edge) => {
+		if (!outgoing.has(edge.source)) outgoing.set(edge.source, []);
+		outgoing.get(edge.source).push({
+			target: edge.target,
+			weight: edge.weight
+		});
+		if (!incoming.has(edge.target)) incoming.set(edge.target, []);
+		incoming.get(edge.target).push({
+			source: edge.source,
+			weight: edge.weight
+		});
+	});
+	for (let iter = 0; iter < iterations; iter++) {
+		for (let layer = 1; layer <= maxLayer; layer++) {
+			const nodes = layers.get(layer) || [];
+			if (nodes.length <= 1) continue;
+			const prevLayer = layers.get(layer - 1) || [];
+			const positionMap = new Map(prevLayer.map((id, idx) => [id, idx]));
+			const metrics = nodes.map((nodeId) => {
+				const parents = incoming.get(nodeId) || [];
+				if (parents.length === 0) return {
+					nodeId,
+					barycenter: 0,
+					median: 0
+				};
+				const positions = parents.map((p) => positionMap.get(p.source)).filter((pos) => pos !== void 0).sort((a, b) => a - b);
+				const weightedSum = parents.reduce((sum, p) => {
+					const pos = positionMap.get(p.source);
+					return pos !== void 0 ? sum + pos * p.weight : sum;
+				}, 0);
+				const totalWeight = parents.reduce((sum, p) => sum + p.weight, 0);
+				return {
+					nodeId,
+					barycenter: totalWeight > 0 ? weightedSum / totalWeight : 0,
+					median: positions.length > 0 ? positions[Math.floor(positions.length / 2)] : 0
+				};
+			});
+			metrics.sort((a, b) => {
+				return (joinTables.has(a.nodeId) ? a.median : a.barycenter) - (joinTables.has(b.nodeId) ? b.median : b.barycenter);
+			});
+			layers.set(layer, metrics.map((m) => m.nodeId));
+		}
+		for (let layer = maxLayer - 1; layer >= 0; layer--) {
+			const nodes = layers.get(layer) || [];
+			if (nodes.length <= 1) continue;
+			const nextLayer = layers.get(layer + 1) || [];
+			const positionMap = new Map(nextLayer.map((id, idx) => [id, idx]));
+			const metrics = nodes.map((nodeId) => {
+				const children = outgoing.get(nodeId) || [];
+				if (children.length === 0) {
+					const currentLayer = layers.get(layer) || [];
+					return {
+						nodeId,
+						barycenter: currentLayer.indexOf(nodeId),
+						median: currentLayer.indexOf(nodeId)
+					};
+				}
+				const positions = children.map((c) => positionMap.get(c.target)).filter((pos) => pos !== void 0).sort((a, b) => a - b);
+				const weightedSum = children.reduce((sum, c) => {
+					const pos = positionMap.get(c.target);
+					return pos !== void 0 ? sum + pos * c.weight : sum;
+				}, 0);
+				const totalWeight = children.reduce((sum, c) => sum + c.weight, 0);
+				return {
+					nodeId,
+					barycenter: totalWeight > 0 ? weightedSum / totalWeight : positions[0] || 0,
+					median: positions.length > 0 ? positions[Math.floor(positions.length / 2)] : 0
+				};
+			});
+			metrics.sort((a, b) => {
+				return (joinTables.has(a.nodeId) ? a.median : a.barycenter) - (joinTables.has(b.nodeId) ? b.median : b.barycenter);
+			});
+			layers.set(layer, metrics.map((m) => m.nodeId));
+		}
+	}
+}
+function adjacentSwapOptimization(layers, edges) {
+	const maxLayer = Math.max(...layers.keys());
+	new Set(edges.map((e) => `${e.source}->${e.target}`));
+	function countCrossings(layer, idx1, idx2) {
+		const node1 = layer[idx1];
+		const node2 = layer[idx2];
+		let crossings = 0;
+		edges.forEach((e1) => {
+			if (e1.source !== node1 && e1.target !== node1) return;
+			edges.forEach((e2) => {
+				if (e2.source !== node2 && e2.target !== node2) return;
+				const e1SourceIdx = layer.indexOf(e1.source);
+				const e1TargetIdx = layer.indexOf(e1.target);
+				const e2SourceIdx = layer.indexOf(e2.source);
+				const e2TargetIdx = layer.indexOf(e2.target);
+				if (e1SourceIdx < e2SourceIdx && e1TargetIdx > e2TargetIdx || e1SourceIdx > e2SourceIdx && e1TargetIdx < e2TargetIdx) crossings++;
+			});
+		});
+		return crossings;
+	}
+	for (let layer = 0; layer <= maxLayer; layer++) {
+		const layerNodes = layers.get(layer) || [];
+		if (layerNodes.length <= 1) continue;
+		let improved = true;
+		let iterations = 0;
+		const maxIterations = 5;
+		while (improved && iterations < maxIterations) {
+			improved = false;
+			iterations++;
+			for (let i = 0; i < layerNodes.length - 1; i++) {
+				const before = countCrossings(layerNodes, i, i + 1);
+				[layerNodes[i], layerNodes[i + 1]] = [layerNodes[i + 1], layerNodes[i]];
+				if (countCrossings(layerNodes, i, i + 1) < before) improved = true;
+				else [layerNodes[i], layerNodes[i + 1]] = [layerNodes[i + 1], layerNodes[i]];
+			}
+		}
+		layers.set(layer, layerNodes);
+	}
+}
+function positionJoinTables(nodes, layers, joinTables, edges) {
+	const incoming = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => incoming.set(node.id, /* @__PURE__ */ new Set()));
+	edges.forEach((edge) => {
+		var _incoming$get3;
+		(_incoming$get3 = incoming.get(edge.target)) === null || _incoming$get3 === void 0 || _incoming$get3.add(edge.source);
+	});
+	joinTables.forEach((joinId) => {
+		const parents = [...incoming.get(joinId) || /* @__PURE__ */ new Set()];
+		if (parents.length >= 2) {
+			let joinLayer = -1;
+			let joinIndex = -1;
+			layers.forEach((layerNodes, layerIdx) => {
+				const idx = layerNodes.indexOf(joinId);
+				if (idx !== -1) {
+					joinLayer = layerIdx;
+					joinIndex = idx;
+				}
+			});
+			if (joinLayer === -1) return;
+			const parentPositions = [];
+			layers.forEach((layerNodes, layerIdx) => {
+				if (layerIdx < joinLayer) parents.forEach((parent) => {
+					const idx = layerNodes.indexOf(parent);
+					if (idx !== -1) parentPositions.push(idx);
+				});
+			});
+			if (parentPositions.length >= 2) {
+				const avgPosition = parentPositions.reduce((a, b) => a + b, 0) / parentPositions.length;
+				const targetIndex = Math.round(avgPosition);
+				const layerNodes = layers.get(joinLayer);
+				layerNodes.splice(joinIndex, 1);
+				const insertIdx = Math.min(targetIndex, layerNodes.length);
+				layerNodes.splice(insertIdx, 0, joinId);
+				layers.set(joinLayer, layerNodes);
+			}
+		}
+	});
+}
+function assignCoordinates(nodes, layers, horizontalSpacing, verticalSpacing, startX, startY) {
+	const positions = {};
+	const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+	layers.forEach((layerNodes, layerIndex) => {
+		let currentX = startX;
+		layerNodes.forEach((nodeId) => {
+			const node = nodeMap.get(nodeId);
+			const nodeWidth = (node === null || node === void 0 ? void 0 : node.width) || 350;
+			positions[nodeId] = {
+				x: currentX,
+				y: startY + layerIndex * verticalSpacing
+			};
+			currentX += nodeWidth + (horizontalSpacing - nodeWidth);
+		});
+	});
+	return positions;
+}
+function balanceColumns(positions, layers) {
+	layers.forEach((layerNodes) => {
+		if (layerNodes.length <= 2) return;
+		const xPositions = layerNodes.map((id) => positions[id].x).sort((a, b) => a - b);
+		const median = xPositions[Math.floor(xPositions.length / 2)];
+		layerNodes.forEach((id) => {
+			const delta = (median - positions[id].x) * .1;
+			positions[id].x += delta;
+		});
+	});
+}
+function calculatePorts(nodes) {
+	const ports = {};
+	nodes.forEach((node) => {
+		const left = [];
+		const right = [];
+		[...node.columns].sort((a, b) => {
+			if (a.isPrimaryKey && !b.isPrimaryKey) return -1;
+			if (!a.isPrimaryKey && b.isPrimaryKey) return 1;
+			if (a.isForeignKey && !b.isForeignKey) return 1;
+			if (!a.isForeignKey && b.isForeignKey) return -1;
+			return 0;
+		}).forEach((col) => {
+			if (col.isPrimaryKey) left.push(col.name);
+			if (col.isForeignKey) right.push(col.name);
+		});
+		ports[node.id] = {
+			left,
+			right
+		};
+	});
+	return ports;
+}
+function generateTableNodeId(baseId, tableId = null) {
+	return `${baseId}-table-${tableId !== null && tableId !== void 0 ? tableId : generateUUID()}`;
+}
+function generateUUID() {
+	let d = (/* @__PURE__ */ new Date()).getTime();
+	let d2 = typeof performance !== "undefined" && performance.now ? performance.now() * 1e3 : 0;
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		let r = Math.random() * 16;
+		if (d > 0) {
+			r = (d + r) % 16 | 0;
+			d = Math.floor(d / 16);
+		} else {
+			r = (d2 + r) % 16 | 0;
+			d2 = Math.floor(d2 / 16);
+		}
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+var AstToUiConverter = class {
+	static updateReactFlow({ nodes, edges, schema, sourceId, oldDataSources }) {
+		console.log("UPDATE:", {
+			nodes,
+			edges,
+			schema,
+			sourceId,
+			oldDataSources
+		});
+		const oldSource = oldDataSources.find((s) => s.id === sourceId);
+		const sourceNodePrefix = `${sourceId}-table-`;
+		const positions = this.calculateSmartLayout(schema);
+		const nodeTableMap = new Map(nodes.map((node) => {
+			var _oldSource$schemaAst$;
+			return [oldSource === null || oldSource === void 0 || (_oldSource$schemaAst$ = oldSource.schemaAst.tables.find((t) => {
+				var _localTable;
+				return t.id === ((_localTable = node.data.localTable) === null || _localTable === void 0 ? void 0 : _localTable.tableId);
+			})) === null || _oldSource$schemaAst$ === void 0 ? void 0 : _oldSource$schemaAst$.name, node];
+		}));
+		console.log("Old node table map:", nodeTableMap);
+		const tableNames = new Set(schema.tables.map((table) => table.name));
+		const sourceNodes = schema.tables.map((table, index) => {
+			var _ref, _ref2, _prevNode$position, _prevNode$data, _prevNode$data$style, _prevNode$data2, _baseNode$data;
+			const prevNode = nodeTableMap.get(table.name);
+			const position = (_ref = (_ref2 = (_prevNode$position = prevNode === null || prevNode === void 0 ? void 0 : prevNode.position) !== null && _prevNode$position !== void 0 ? _prevNode$position : table.position) !== null && _ref2 !== void 0 ? _ref2 : positions[table.name]) !== null && _ref !== void 0 ? _ref : {
+				x: 100,
+				y: 100 + index * 210
+			};
+			const baseNode = this.tableAstToNode(sourceId, table, position, tableNames);
+			if (!prevNode) return baseNode;
+			const mergedNode = _objectSpread2(_objectSpread2(_objectSpread2({}, prevNode), baseNode), {}, { data: _objectSpread2(_objectSpread2(_objectSpread2({}, (_prevNode$data = prevNode.data) !== null && _prevNode$data !== void 0 ? _prevNode$data : {}), baseNode.data), {}, { style: (_prevNode$data$style = (_prevNode$data2 = prevNode.data) === null || _prevNode$data2 === void 0 ? void 0 : _prevNode$data2.style) !== null && _prevNode$data$style !== void 0 ? _prevNode$data$style : (_baseNode$data = baseNode.data) === null || _baseNode$data === void 0 ? void 0 : _baseNode$data.style }) });
+			if (prevNode.style) mergedNode.style = prevNode.style;
+			if (prevNode.width !== void 0) mergedNode.width = prevNode.width;
+			if (prevNode.height !== void 0) mergedNode.height = prevNode.height;
+			return mergedNode;
+		}).filter((node) => {
+			var _schema$tables$find;
+			return nodeTableMap.has((_schema$tables$find = schema.tables.find((t) => {
+				var _localTable2;
+				return t.id === ((_localTable2 = node.data.localTable) === null || _localTable2 === void 0 ? void 0 : _localTable2.tableId);
+			})) === null || _schema$tables$find === void 0 ? void 0 : _schema$tables$find.name);
+		});
+		const validNodeIds = new Set(sourceNodes.map((node) => node.id));
+		const sourceEdges = schema.tables.flatMap((table) => this.createEdgesFromTable(sourceId, table, schema.tables).filter((edge) => validNodeIds.has(edge.source) && validNodeIds.has(edge.target)));
+		const preservedNodes = nodes.filter((node) => !node.id.startsWith(sourceNodePrefix));
+		const preservedEdges = edges.filter((edge) => !edge.id.startsWith(sourceNodePrefix));
+		return {
+			nodes: [...preservedNodes, ...sourceNodes],
+			edges: [...preservedEdges, ...sourceEdges]
+		};
+	}
+	static toReactFlow(schema, sourceId) {
+		const nodes = [];
+		const edges = [];
+		const tableNames = new Set(schema.tables.map((table) => table.name));
+		const positions = this.calculateSmartLayout(schema);
+		schema.tables.forEach((table, index) => {
+			const position = table.position || positions[table.name] || {
+				x: 100,
+				y: 100 + index * 210
+			};
+			const node = this.tableAstToNode(sourceId, table, position, tableNames);
+			nodes.push(node);
+			const tableEdges = this.createEdgesFromTable(sourceId, table, schema.tables);
+			edges.push(...tableEdges);
+		});
+		return {
+			nodes,
+			edges
+		};
+	}
+	static calculateSmartLayout(schema) {
+		const positions = {};
+		const tableNames = new Set(schema.tables.map((table) => table.name));
+		const relationships = /* @__PURE__ */ new Map();
+		schema.tables.forEach((table) => {
+			if (!relationships.has(table.name)) relationships.set(table.name, /* @__PURE__ */ new Set());
+			this.extractForeignKeys(table).forEach((fk) => {
+				if (!tableNames.has(fk.referencedTable)) return;
+				relationships.get(table.name).add(fk.referencedTable);
+				if (!relationships.has(fk.referencedTable)) relationships.set(fk.referencedTable, /* @__PURE__ */ new Set());
+				relationships.get(fk.referencedTable).add(table.name);
+			});
+		});
+		const visited = /* @__PURE__ */ new Set();
+		const components = [];
+		function dfs(tableName, component) {
+			visited.add(tableName);
+			component.push(tableName);
+			(relationships.get(tableName) || /* @__PURE__ */ new Set()).forEach((neighbor) => {
+				if (!visited.has(neighbor)) dfs(neighbor, component);
+			});
+		}
+		schema.tables.forEach((table) => {
+			if (!visited.has(table.name)) {
+				const component = [];
+				dfs(table.name, component);
+				components.push(component);
+			}
+		});
+		let componentOffsetX = DEFAULT_NODE_X_OFFSET;
+		components.forEach((component) => {
+			if (component.length === 1) {
+				positions[component[0]] = {
+					x: componentOffsetX,
+					y: DEFAULT_NODE_Y_OFFSET
+				};
+				componentOffsetX += DEFAULT_NODE_X_SPACING;
+			} else {
+				const componentPositions = this.layoutComponentHierarchical(component, relationships, componentOffsetX, schema);
+				Object.assign(positions, componentPositions);
+				componentOffsetX = Math.max(...Object.values(componentPositions).map((p) => p.x)) + DEFAULT_NODE_WIDTH + DEFAULT_NODE_X_SPACING;
+			}
+		});
+		return positions;
+	}
+	static layoutComponentHierarchical(tables, relationships, startX, schema) {
+		const tableMap = new Map(schema.tables.filter((t) => tables.includes(t.name)).map((t) => [t.name, t]));
+		const nodes = arrayNonNullable(tables.map((tableName) => {
+			const table = tableMap.get(tableName);
+			if (!table) return null;
+			return {
+				id: tableName,
+				width: 350,
+				height: Math.max(200, table.columns.length * 30 + 80),
+				columns: table.columns.map((col) => {
+					const primaryKeys = this.extractPrimaryKeys(table);
+					const foreignKeys = this.extractForeignKeys(table);
+					return {
+						name: col.name,
+						isPrimaryKey: primaryKeys.includes(col.name),
+						isForeignKey: foreignKeys.some((fk) => fk.columns.includes(col.name))
+					};
+				})
+			};
+		}));
+		const edges = [];
+		const componentSet = new Set(tables);
+		schema.tables.forEach((table) => {
+			if (!componentSet.has(table.name)) return;
+			this.extractForeignKeys(table).forEach((fk) => {
+				if (componentSet.has(fk.referencedTable) && tableMap.has(fk.referencedTable)) {
+					const primaryKeys = this.extractPrimaryKeys(table);
+					const isPrimaryFK = fk.columns.some((col) => primaryKeys.includes(col));
+					edges.push({
+						source: table.name,
+						target: fk.referencedTable,
+						sourceColumn: fk.columns[0],
+						targetColumn: fk.referencedColumns[0],
+						weight: isPrimaryFK ? 2 : 1
+					});
+				}
+			});
+		});
+		return computeLayeredLayout(nodes, edges, {
+			horizontalSpacing: DEFAULT_NODE_X_SPACING,
+			verticalSpacing: DEFAULT_NODE_Y_SPACING,
+			startY: DEFAULT_NODE_Y_OFFSET,
+			startX
+		}).positions;
+	}
+	static tableAstToNode(sourceId, table, position, _validTableNames) {
+		return {
+			id: generateTableNodeId(sourceId, table.id),
+			type: "databaseTableSQL",
+			width: DEFAULT_NODE_WIDTH,
+			position,
+			data: { localTable: {
+				baseId: sourceId,
+				tableId: table.id
+			} }
+		};
+	}
+	static extractPrimaryKeys(table) {
+		const pkConstraint = table.constraints.find((c) => c.type === "primary_key");
+		if (pkConstraint) return pkConstraint.columns;
+		return table.columns.filter((col) => col.autoIncrement).map((col) => col.name);
+	}
+	static extractForeignKeys(table) {
+		return table.constraints.filter((c) => c.type === "foreign_key");
+	}
+	static formatDataType(column) {
+		const { dataType } = column;
+		let formatted = dataType.name;
+		if (dataType.parameters && dataType.parameters.length > 0) formatted += `(${dataType.parameters.join(", ")})`;
+		if (dataType.unsigned) formatted += " UNSIGNED";
+		if (dataType.timezone) formatted += " WITH TIME ZONE";
+		return formatted;
+	}
+	static createEdgesFromTable(baseId, sourceTable, validTables) {
+		const edges = [];
+		this.extractForeignKeys(sourceTable).forEach((fk, index) => {
+			const targetTable = validTables.find((t) => t.id === fk.referencedTable || t.name === fk.referencedTable);
+			if (!targetTable) return;
+			const sourceNodeId = generateTableNodeId(baseId, sourceTable.id);
+			const targetNodeId = generateTableNodeId(baseId, targetTable.id);
+			const edgeId = `${sourceNodeId}-fk-${index}`;
+			const fkCols = fk.columns;
+			const allNotNull = fkCols.every((cn) => {
+				const col = sourceTable.columns.find((c) => c.name === cn);
+				return col ? col.nullable === false : false;
+			});
+			const hasUniqueConstraint = sourceTable.constraints.some((c) => c.type === "unique" && c.columns.length === fkCols.length && fkCols.every((cn) => c.columns.includes(cn)));
+			const hasUniqueIndex = sourceTable.indexes.some((idx) => idx.unique && idx.columns.length === fkCols.length && fkCols.every((cn) => idx.columns.some((ic) => ic.name === cn)));
+			const isUnique = hasUniqueConstraint || hasUniqueIndex;
+			const startMarkerType = allNotNull ? "erdOnlyOne" : "erdZeroOrOne";
+			const endMarkerType = isUnique ? "erdZeroOrOne" : "erdZeroOrMany";
+			edges.push({
+				id: edgeId,
+				source: sourceNodeId,
+				target: targetNodeId,
+				type: "smoothstep",
+				animated: false,
+				markerEnd: createEdgeMarker({ type: endMarkerType }),
+				markerStart: createEdgeMarker({ type: startMarkerType }),
+				label: `${fk.columns.join(", ")} → ${fk.referencedColumns.join(", ")}`,
+				style: {
+					stroke: "#3b82f6",
+					strokeWidth: 2.5
+				},
+				labelStyle: {
+					fontSize: 11,
+					fill: "#475569",
+					fontWeight: 500
+				},
+				labelBgStyle: {
+					fill: "#ffffff",
+					fillOpacity: .85
+				}
+			});
+		});
+		return edges;
+	}
+};
+var AstToSqlGenerator = class {
+	constructor(dialect = "mysql", indentSize = 2) {
+		_defineProperty(this, "dialect", void 0);
+		_defineProperty(this, "indentSize", void 0);
+		this.dialect = dialect;
+		this.indentSize = indentSize;
+	}
+	generateNoSQL(schema) {
+		return JSON.stringify({ tables: schema.tables }, null, this.indentSize);
+	}
+	generateSQL(schema) {
+		const statements = [];
+		statements.push(`-- Generated SQL Schema (${schema.dialect.toUpperCase()})`);
+		statements.push(`-- Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+		statements.push("");
+		schema.tables.forEach((table) => {
+			const sql = this.generateCreateTable(table);
+			statements.push(sql);
+			statements.push("");
+		});
+		return statements.join("\n");
+	}
+	generate(schema) {
+		switch (this.dialect) {
+			case "dynamodb":
+			case "mongodb":
+			case "json": return this.generateNoSQL(schema);
+			default: return this.generateSQL(schema);
+		}
+	}
+	generateCreateTable(table) {
+		const lines = [];
+		const indent = " ".repeat(this.indentSize);
+		const tableName = this.quoteIdentifier(table.name);
+		lines.push(`CREATE TABLE IF NOT EXISTS ${tableName} (`);
+		const definitions = [];
+		table.columns.forEach((column) => {
+			definitions.push(this.generateColumn(column));
+		});
+		table.constraints.forEach((constraint) => {
+			definitions.push(this.generateConstraint(constraint));
+		});
+		if (this.dialect === "mysql") table.indexes.forEach((index) => {
+			definitions.push(this.generateIndex(index));
+		});
+		lines.push(definitions.map((def) => `${indent}${def}`).join(",\n"));
+		lines.push(")");
+		const options = this.generateTableOptions(table);
+		if (options) lines[lines.length - 1] += ` ${options}`;
+		lines[lines.length - 1] += ";";
+		if (this.dialect === "postgresql") table.indexes.forEach((index) => {
+			lines.push("");
+			lines.push(this.generatePostgresIndex(index, table.name));
+		});
+		return lines.join("\n");
+	}
+	generateColumn(column) {
+		const parts = [];
+		parts.push(this.quoteIdentifier(column.name));
+		parts.push(this.generateDataType(column.dataType));
+		parts.push(column.nullable ? "NULL" : "NOT NULL");
+		if (column.defaultValue) parts.push(`DEFAULT ${this.generateDefaultValue(column.defaultValue)}`);
+		if (column.autoIncrement) {
+			if (this.dialect === "mysql") parts.push("AUTO_INCREMENT");
+			else if (this.dialect === "postgresql") {}
+		}
+		if (column.comment) {
+			if (this.dialect === "mysql") parts.push(`COMMENT '${column.comment.replace(/'/g, "''")}'`);
+		}
+		return parts.join(" ");
+	}
+	generateDataType(dataType) {
+		let type = dataType.name;
+		if (dataType.parameters && dataType.parameters.length > 0) type += `(${dataType.parameters.join(", ")})`;
+		if (dataType.unsigned) type += " UNSIGNED";
+		if (dataType.timezone) type += " WITH TIME ZONE";
+		return type;
+	}
+	generateDefaultValue(defaultValue) {
+		if (defaultValue.type === "literal") {
+			if (defaultValue.value === null) return "NULL";
+			if (typeof defaultValue.value === "string") return `'${defaultValue.value.replace(/'/g, "''")}'`;
+			return String(defaultValue.value);
+		}
+		if (defaultValue.type === "function" || defaultValue.type === "expression") return defaultValue.raw || String(defaultValue.value);
+		return String(defaultValue.value);
+	}
+	generateConstraint(constraint) {
+		switch (constraint.type) {
+			case "primary_key": return this.generatePrimaryKey(constraint);
+			case "foreign_key": return this.generateForeignKey(constraint);
+			case "unique": return this.generateUnique(constraint);
+			case "check": return this.generateCheck(constraint);
+			default: return "";
+		}
+	}
+	generatePrimaryKey(constraint) {
+		const columns = constraint.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+		if (constraint.name) return `CONSTRAINT ${this.quoteIdentifier(constraint.name)} PRIMARY KEY (${columns})`;
+		return `PRIMARY KEY (${columns})`;
+	}
+	generateForeignKey(constraint) {
+		const parts = [];
+		if (constraint.name) parts.push(`CONSTRAINT ${this.quoteIdentifier(constraint.name)}`);
+		const columns = constraint.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+		const refTable = this.quoteIdentifier(constraint.referencedTable);
+		const refColumns = constraint.referencedColumns.map((c) => this.quoteIdentifier(c)).join(", ");
+		parts.push(`FOREIGN KEY (${columns})`);
+		parts.push(`REFERENCES ${refTable} (${refColumns})`);
+		if (constraint.onDelete) parts.push(`ON DELETE ${constraint.onDelete}`);
+		if (constraint.onUpdate) parts.push(`ON UPDATE ${constraint.onUpdate}`);
+		return parts.join(" ");
+	}
+	generateUnique(constraint) {
+		const columns = constraint.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+		if (constraint.name) return `CONSTRAINT ${this.quoteIdentifier(constraint.name)} UNIQUE (${columns})`;
+		return `UNIQUE (${columns})`;
+	}
+	generateCheck(constraint) {
+		if (constraint.name) return `CONSTRAINT ${this.quoteIdentifier(constraint.name)} CHECK (${constraint.expression})`;
+		return `CHECK (${constraint.expression})`;
+	}
+	generateIndex(index) {
+		const parts = [];
+		if (index.unique) parts.push("UNIQUE");
+		parts.push("INDEX");
+		parts.push(this.quoteIdentifier(index.name));
+		const columns = index.columns.map((col) => {
+			let colDef = this.quoteIdentifier(col.name);
+			if (col.length) colDef += `(${col.length})`;
+			if (col.order) colDef += ` ${col.order}`;
+			return colDef;
+		});
+		parts.push(`(${columns.join(", ")})`);
+		if (index.method && this.dialect === "mysql") parts.push(`USING ${index.method.toUpperCase()}`);
+		return parts.join(" ");
+	}
+	generatePostgresIndex(index, tableName) {
+		const parts = [];
+		parts.push("CREATE");
+		if (index.unique) parts.push("UNIQUE");
+		parts.push("INDEX");
+		parts.push(this.quoteIdentifier(index.name));
+		parts.push("ON");
+		parts.push(this.quoteIdentifier(tableName));
+		if (index.method) parts.push(`USING ${index.method.toUpperCase()}`);
+		const columns = index.columns.map((col) => {
+			let colDef = this.quoteIdentifier(col.name);
+			if (col.order) colDef += ` ${col.order}`;
+			return colDef;
+		});
+		parts.push(`(${columns.join(", ")})`);
+		if (index.where) parts.push(`WHERE ${index.where}`);
+		return parts.join(" ") + ";";
+	}
+	generateTableOptions(table) {
+		if (!table.options) return null;
+		const parts = [];
+		if (this.dialect === "mysql") {
+			if (table.options.engine) parts.push(`ENGINE=${table.options.engine}`);
+			if (table.options.charset) parts.push(`CHARACTER SET ${table.options.charset}`);
+			if (table.options.collation) parts.push(`COLLATE ${table.options.collation}`);
+			if (table.options.autoIncrement) parts.push(`AUTO_INCREMENT=${table.options.autoIncrement}`);
+			if (table.options.comment) parts.push(`COMMENT='${table.options.comment.replace(/'/g, "''")}'`);
+		}
+		if (this.dialect === "postgresql") {
+			if (table.options.tablespace) parts.push(`TABLESPACE ${table.options.tablespace}`);
+		}
+		return parts.length > 0 ? parts.join(" ") : null;
+	}
+	quoteIdentifier(identifier) {
+		switch (this.dialect) {
+			case "mysql": return `\`${identifier}\``;
+			case "postgresql": return `"${identifier}"`;
+			case "sqlite": return `"${identifier}"`;
+			default: return identifier;
+		}
+	}
+};
+var SqlToAstParser = class {
+	constructor(dialect = "mysql") {
+		_defineProperty(this, "dialect", void 0);
+		this.dialect = dialect;
+	}
+	parseSQL(sqlContent) {
+		const tables = this.extractTables(sqlContent);
+		return {
+			dialect: this.dialect,
+			tables,
+			metadata: { createdAt: /* @__PURE__ */ new Date() }
+		};
+	}
+	parseNoSQL(noSQLJsonContent) {
+		const parsed = JSON.parse(noSQLJsonContent || "{}");
+		const existingTables = Array.isArray(parsed.tables) ? parsed.tables : null;
+		if (existingTables && existingTables.length > 0) return {
+			dialect: this.dialect,
+			tables: existingTables,
+			metadata: { createdAt: /* @__PURE__ */ new Date() }
+		};
+		const tables = (Array.isArray(parsed.collections) ? parsed.collections : []).map((collection) => {
+			if (!collection || !collection.name) return null;
+			const fields = collection.fields && typeof collection.fields === "object" ? collection.fields : {};
+			const columns = Object.entries(fields).map(([name, type]) => ({
+				type: "column",
+				name,
+				dataType: this.parseNoSqlType(String(type || "string")),
+				nullable: true
+			}));
+			return {
+				type: "table",
+				id: generateUUID$1(),
+				name: collection.name,
+				columns,
+				constraints: [],
+				indexes: []
+			};
+		}).filter(Boolean);
+		return {
+			dialect: this.dialect,
+			tables,
+			metadata: { createdAt: /* @__PURE__ */ new Date() }
+		};
+	}
+	parse(sqlContent, useStrictNoSQL = false) {
+		switch (this.dialect) {
+			case "json":
+			case "mongodb":
+			case "dynamodb":
+				if (useStrictNoSQL) return convertNoSQLToAst(JSON.parse(sqlContent));
+				return this.parseNoSQL(sqlContent);
+			default: return this.parseSQL(sqlContent);
+		}
+	}
+	static detectDialect(sqlContent) {
+		const content = sqlContent.toLowerCase();
+		try {
+			JSON.parse(sqlContent);
+			return "json";
+		} catch (_unused) {}
+		if (content.includes("serial") || content.includes("bigserial") || content.includes("::") || content.includes("nextval(") || content.includes("create schema")) return "postgresql";
+		if (content.includes("engine=") || content.includes("auto_increment") || content.includes("unsigned") || content.includes("character set") || content.includes("collate")) return "mysql";
+		return "mysql";
+	}
+	extractTables(sqlContent) {
+		const tables = [];
+		const tableMap = /* @__PURE__ */ new Map();
+		const cleanedSQL = this.cleanSql(sqlContent);
+		const createTableRegex = /CREATE\s+TABLE[\s\S]*?;/gi;
+		let match;
+		while ((match = createTableRegex.exec(cleanedSQL)) !== null) {
+			const statement = match[0];
+			const components = this.extractCreateTableComponents(statement);
+			if (!components) continue;
+			const { rawIdentifier, tableName, tableBody, tableOptions } = components;
+			const tableKey = this.normalizeTableKey(rawIdentifier);
+			if (tableMap.has(tableKey)) continue;
+			try {
+				const table = this.parseTableDefinition(tableName, tableBody, tableOptions);
+				tables.push(table);
+				tableMap.set(tableKey, table);
+			} catch (error) {
+				console.error("Error parsing table:", error);
+			}
+		}
+		this.applyAlterTableStatements(cleanedSQL, tableMap);
+		return tables;
+	}
+	extractCreateTableComponents(statement) {
+		const trimmedStatement = statement.trim();
+		const headerMatch = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:`[^`]+`|"[^"]+"|'[^']+'|\[[^\]]+\]|\w+)(?:\.(?:`[^`]+`|"[^"]+"|'[^']+'|\[[^\]]+\]|\w+))?)\s*\(/i.exec(trimmedStatement);
+		if (!headerMatch) return null;
+		const rawIdentifier = headerMatch[1];
+		const openParenIndex = headerMatch[0].length - 1;
+		const closeParenIndex = this.findClosingParenthesis(trimmedStatement, openParenIndex);
+		if (closeParenIndex === -1) return null;
+		const body = trimmedStatement.slice(openParenIndex + 1, closeParenIndex);
+		const options = trimmedStatement.slice(closeParenIndex + 1, trimmedStatement.length - 1).trim();
+		return {
+			rawIdentifier,
+			tableName: this.normalizeTableName(rawIdentifier),
+			tableBody: body,
+			tableOptions: options
+		};
+	}
+	findClosingParenthesis(str, startIndex) {
+		let depth = 0;
+		let inQuotes = false;
+		let quoteChar = "";
+		for (let i = startIndex; i < str.length; i++) {
+			const char = str[i];
+			const prevChar = i > 0 ? str[i - 1] : "";
+			if ((char === "\"" || char === "'" || char === "`") && prevChar !== "\\") {
+				if (!inQuotes) {
+					inQuotes = true;
+					quoteChar = char;
+				} else if (char === quoteChar) {
+					inQuotes = false;
+					quoteChar = "";
+				}
+			}
+			if (inQuotes) continue;
+			if (char === "(") depth++;
+			else if (char === ")") {
+				depth--;
+				if (depth === 0) return i;
+			}
+		}
+		return -1;
+	}
+	applyAlterTableStatements(sqlContent, tableMap) {
+		const alterRegex = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?((?:`[^`]+`|"[^"]+"|'[^']+'|\[[^\]]+\]|[\w$]+)(?:\.(?:`[^`]+`|"[^"]+"|'[^']+'|\[[^\]]+\]|[\w$]+))?)\s+([\s\S]*?);/gi;
+		let match;
+		while ((match = alterRegex.exec(sqlContent)) !== null) {
+			const rawIdentifier = match[1];
+			const actionsBlock = match[2] || "";
+			if (!rawIdentifier) continue;
+			const table = tableMap.get(this.normalizeTableKey(rawIdentifier));
+			if (!table) continue;
+			const actions = this.splitTableBody(actionsBlock);
+			for (const action of actions) {
+				const trimmed = action.trim();
+				if (!trimmed) continue;
+				if (/^ADD\s+/i.test(trimmed)) {
+					const definition = trimmed.replace(/^ADD\s+/i, "").trim();
+					if (!definition) continue;
+					const constraint = this.parseConstraint(definition);
+					if (constraint) {
+						table.constraints.push(constraint);
+						continue;
+					}
+					const index = this.parseIndex(definition);
+					if (index) table.indexes.push(index);
+				}
+			}
+		}
+	}
+	cleanSql(sql) {
+		return sql.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\r\n/g, "\n").trim();
+	}
+	cleanIdentifier(identifier) {
+		return identifier.replace(/[`"'\[\]]/g, "").trim();
+	}
+	normalizeTableName(identifier) {
+		const cleaned = this.cleanIdentifier(identifier);
+		if (!cleaned) return "";
+		const parts = cleaned.split(".");
+		return parts[parts.length - 1];
+	}
+	normalizeTableKey(identifier) {
+		return this.cleanIdentifier(identifier).toLowerCase();
+	}
+	parseNoSqlType(rawType) {
+		const trimmed = rawType.trim();
+		const lower = trimmed.toLowerCase();
+		if (lower.startsWith("array<") && lower.endsWith(">")) return { name: `array<${trimmed.slice(6, -1).trim() || "string"}>` };
+		return { name: trimmed || "string" };
+	}
+	parseTableDefinition(tableName, tableBody, tableOptionsStr) {
+		const columns = [];
+		const constraints = [];
+		const indexes = [];
+		const pendingColumns = [];
+		const lines = this.splitTableBody(tableBody);
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (!trimmedLine) continue;
+			try {
+				const tableLevelPattern = /^(?:CONSTRAINT|PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CHECK|INDEX|KEY)\b/i;
+				let column = null;
+				if (!tableLevelPattern.test(trimmedLine)) {
+					column = this.parseColumn(trimmedLine);
+					if (column) {
+						pendingColumns.push({
+							column,
+							hasType: !!column.dataType.name
+						});
+						this.applyInlineColumnConstraints(trimmedLine, column, constraints);
+						continue;
+					}
+				}
+				const constraint = this.parseConstraint(trimmedLine);
+				if (constraint) {
+					constraints.push(constraint);
+					continue;
+				}
+				const index = this.parseIndex(trimmedLine);
+				if (index) {
+					indexes.push(index);
+					continue;
+				}
+				if (!column) column = this.parseColumn(trimmedLine);
+				if (column) {
+					pendingColumns.push({
+						column,
+						hasType: !!column.dataType.name
+					});
+					this.applyInlineColumnConstraints(trimmedLine, column, constraints);
+				}
+			} catch (error) {
+				console.warn("Error parsing line:", trimmedLine, error);
+			}
+		}
+		const typedColumnsCount = pendingColumns.filter((c) => c.hasType).length;
+		pendingColumns.forEach((entry, index) => {
+			if (!entry.hasType) {
+				const hasTypedAfter = pendingColumns.slice(index + 1).some((c) => c.hasType);
+				if (!(typedColumnsCount < 4 && hasTypedAfter)) return;
+			}
+			columns.push(entry.column);
+		});
+		const options = this.parseTableOptions(tableOptionsStr);
+		return {
+			type: "table",
+			id: generateUUID$1(),
+			name: tableName,
+			columns,
+			constraints,
+			indexes,
+			options
+		};
+	}
+	splitTableBody(body) {
+		const lines = [];
+		let currentLine = "";
+		let parenthesesDepth = 0;
+		let inQuotes = false;
+		let quoteChar = "";
+		for (let i = 0; i < body.length; i++) {
+			const char = body[i];
+			const prevChar = i > 0 ? body[i - 1] : "";
+			if ((char === "\"" || char === "'" || char === "`") && prevChar !== "\\") {
+				if (!inQuotes) {
+					inQuotes = true;
+					quoteChar = char;
+				} else if (char === quoteChar) {
+					inQuotes = false;
+					quoteChar = "";
+				}
+			}
+			if (!inQuotes) {
+				if (char === "(") parenthesesDepth++;
+				else if (char === ")") parenthesesDepth--;
+			}
+			if (char === "," && parenthesesDepth === 0 && !inQuotes) {
+				lines.push(currentLine.trim());
+				currentLine = "";
+			} else currentLine += char;
+		}
+		if (currentLine.trim()) lines.push(currentLine.trim());
+		return lines;
+	}
+	parseColumn(line) {
+		var _ref, _ref2, _ref3, _ref4, _match$, _match$2;
+		const match = line.match(/^(?:`([^`]+)`|"([^"]+)"|'([^']+)'|\[([^\]]+)\]|([a-zA-Z_][\w$]*))\s+([\s\S]+)$/i);
+		if (!match) return null;
+		const rawName = (_ref = (_ref2 = (_ref3 = (_ref4 = (_match$ = match[1]) !== null && _match$ !== void 0 ? _match$ : match[2]) !== null && _ref4 !== void 0 ? _ref4 : match[3]) !== null && _ref3 !== void 0 ? _ref3 : match[4]) !== null && _ref2 !== void 0 ? _ref2 : match[5]) !== null && _ref !== void 0 ? _ref : "";
+		if (!rawName) return null;
+		const definition = (_match$2 = match[6]) === null || _match$2 === void 0 ? void 0 : _match$2.trim().replace(/,+$/, "");
+		if (!definition) return null;
+		const { dataTypeStr, constraintsStr } = this.splitColumnDefinition(definition);
+		const constraintsSegment = constraintsStr || "";
+		const dataType = this.parseDataType(dataTypeStr);
+		let nullable = !/NOT\s+NULL/i.test(constraintsSegment);
+		const autoIncrement = /AUTO_INCREMENT/i.test(constraintsSegment) || /AUTOINCREMENT/i.test(constraintsSegment) || /(SERIAL|BIGSERIAL)/i.test(dataTypeStr);
+		if (autoIncrement || /\bPRIMARY\s+KEY\b/i.test(constraintsSegment)) nullable = false;
+		let defaultValue;
+		const defaultMatch = constraintsSegment.match(/DEFAULT\s+((?:'[^']*'|"[^"]*"|\([^)]*\)|[^\s,]+))/i);
+		if (defaultMatch) defaultValue = this.parseDefaultValue(defaultMatch[1]);
+		let comment;
+		const commentMatch = constraintsSegment.match(/COMMENT\s+['"]([^'"]+)['"]/i);
+		if (commentMatch) comment = commentMatch[1];
+		const column = {
+			type: "column",
+			name: this.cleanIdentifier(rawName),
+			dataType,
+			nullable,
+			defaultValue,
+			autoIncrement,
+			comment
+		};
+		const collateMatch = constraintsSegment.match(/COLLATE\s+([^\s,]+)/i) || line.match(/COLLATE\s+([^\s,]+)/i);
+		if (collateMatch) column.collation = this.cleanIdentifier(collateMatch[1]);
+		const charsetMatch = constraintsSegment.match(/CHARACTER\s+SET\s+([^\s,]+)/i) || constraintsSegment.match(/CHARSET\s*=?\s*([^\s,]+)/i) || line.match(/CHARACTER\s+SET\s+([^\s,]+)/i) || line.match(/CHARSET\s*=?\s*([^\s,]+)/i);
+		if (charsetMatch) column.charset = this.cleanIdentifier(charsetMatch[1]);
+		return column;
+	}
+	splitColumnDefinition(definition) {
+		const match = /\b(?:GENERATED|DEFAULT|NOT\s+NULL|NULL|UNIQUE|PRIMARY\s+KEY|CHECK|REFERENCES|COLLATE|COMMENT|AUTO(?:_|\s*)INCREMENT|ON\s+UPDATE|ON\s+DELETE|CONSTRAINT)\b/i.exec(definition);
+		if (!match) return {
+			dataTypeStr: definition.trim(),
+			constraintsStr: ""
+		};
+		return {
+			dataTypeStr: definition.slice(0, match.index).trim(),
+			constraintsStr: definition.slice(match.index).trim()
+		};
+	}
+	applyInlineColumnConstraints(line, column, constraints) {
+		const columnName = column.name;
+		if (/\bPRIMARY\s+KEY\b/i.test(line)) {
+			const nameMatch = line.match(/CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?.*PRIMARY\s+KEY/i);
+			const name = nameMatch ? this.cleanIdentifier(nameMatch[1]) : void 0;
+			const existing = constraints.find((c) => c.type === "primary_key");
+			if (existing) {
+				if (!existing.columns.includes(columnName)) existing.columns.push(columnName);
+			} else constraints.push({
+				type: "primary_key",
+				name,
+				columns: [columnName]
+			});
+		}
+		if (/\bUNIQUE\b/i.test(line) && !/\bUNIQUE\s+(?:KEY|INDEX)\b/i.test(line)) {
+			const nameMatch = line.match(/CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?.*UNIQUE/i);
+			const name = nameMatch ? this.cleanIdentifier(nameMatch[1]) : void 0;
+			if (!constraints.some((c) => c.type === "unique" && c.columns.length === 1 && c.columns[0] === columnName)) constraints.push({
+				type: "unique",
+				name,
+				columns: [columnName]
+			});
+		}
+		const referencesMatch = line.match(/REFERENCES\s+([^\s(]+)\s*\(([^)]+)\)/i);
+		if (referencesMatch) {
+			const nameMatch = line.match(/CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?.*FOREIGN\s+KEY/i);
+			const name = nameMatch ? this.cleanIdentifier(nameMatch[1]) : void 0;
+			const referencedTable = this.normalizeTableName(referencesMatch[1]);
+			const referencedColumns = referencesMatch[2].split(",").map((c) => this.cleanIdentifier(c.trim()));
+			const onDelete = this.extractReferentialAction(line, "DELETE");
+			const onUpdate = this.extractReferentialAction(line, "UPDATE");
+			if (!constraints.some((c) => c.type === "foreign_key" && c.columns.length === 1 && c.columns[0] === columnName && c.referencedTable === referencedTable)) constraints.push({
+				type: "foreign_key",
+				name,
+				columns: [columnName],
+				referencedTable,
+				referencedColumns,
+				onDelete,
+				onUpdate
+			});
+		}
+		if (/CHECK\s*\(/i.test(line)) {
+			const check = this.parseCheck(line);
+			if (check && !constraints.some((c) => c.type === "check" && c.expression === check.expression)) constraints.push(check);
+		}
+	}
+	parseDataType(dataTypeStr) {
+		const match = dataTypeStr.match(/^(\w+)(?:\(([^)]+)\))?(.*)?$/i);
+		if (!match) return { name: dataTypeStr.trim().toUpperCase() };
+		const name = match[1].toUpperCase();
+		const paramsStr = match[2];
+		const modifiers = match[3] || "";
+		const dataType = { name };
+		if (paramsStr) dataType.parameters = paramsStr.split(",").map((p) => {
+			const trimmed = p.trim();
+			const num = Number(trimmed);
+			return isNaN(num) ? trimmed : num;
+		});
+		dataType.unsigned = /UNSIGNED/i.test(modifiers);
+		dataType.timezone = /WITH TIME ZONE/i.test(modifiers);
+		return dataType;
+	}
+	parseDefaultValue(value) {
+		const trimmed = value.trim();
+		if (/^NULL$/i.test(trimmed)) return {
+			type: "literal",
+			value: null,
+			raw: trimmed
+		};
+		if (/\w+\(.*\)/i.test(trimmed)) return {
+			type: "function",
+			value: trimmed,
+			raw: trimmed
+		};
+		if (/^['"].*['"]$/.test(trimmed)) return {
+			type: "literal",
+			value: trimmed.slice(1, -1),
+			raw: trimmed
+		};
+		const num = Number(trimmed);
+		if (!isNaN(num)) return {
+			type: "literal",
+			value: num,
+			raw: trimmed
+		};
+		return {
+			type: "expression",
+			value: trimmed,
+			raw: trimmed
+		};
+	}
+	parseConstraint(line) {
+		if (/PRIMARY\s+KEY/i.test(line)) return this.parsePrimaryKey(line);
+		if (/FOREIGN\s+KEY/i.test(line)) return this.parseForeignKey(line);
+		if (/UNIQUE/i.test(line) && !/INDEX|KEY/i.test(line)) return this.parseUnique(line);
+		if (/CHECK/i.test(line)) return this.parseCheck(line);
+		return null;
+	}
+	parsePrimaryKey(line) {
+		const match = line.match(/(?:CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?\s+)?PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+		if (!match) return null;
+		return {
+			type: "primary_key",
+			name: match[1] ? this.cleanIdentifier(match[1]) : void 0,
+			columns: match[2].split(",").map((c) => this.cleanIdentifier(c.trim()))
+		};
+	}
+	parseForeignKey(line) {
+		const match = line.match(/(?:CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?\s+)?FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+((?:["'`]?[\w$]+["'`"]?|\[[^\]]+\])(?:\.(?:["'`]?[\w$]+["'`"]?|\[[^\]]+\]))?)\s*\(([^)]+)\)/i);
+		if (!match) return null;
+		return {
+			type: "foreign_key",
+			name: match[1] ? this.cleanIdentifier(match[1]) : void 0,
+			columns: match[2].split(",").map((c) => this.cleanIdentifier(c.trim())),
+			referencedTable: this.normalizeTableName(match[3]),
+			referencedColumns: match[4].split(",").map((c) => this.cleanIdentifier(c.trim())),
+			onDelete: this.extractReferentialAction(line, "DELETE"),
+			onUpdate: this.extractReferentialAction(line, "UPDATE")
+		};
+	}
+	extractReferentialAction(segment, actionType) {
+		const regex = new RegExp(`ON\\s+${actionType}\\s+([A-Z\\s]+?)(?=\\s+ON\\s+(?:DELETE|UPDATE)\\b|,|\\)|$)`, "i");
+		const match = segment.match(regex);
+		if (!match) return void 0;
+		const normalized = match[1].trim().replace(/\s+/g, " ").toUpperCase();
+		if (normalized === "CASCADE" || normalized === "SET NULL" || normalized === "SET DEFAULT" || normalized === "RESTRICT" || normalized === "NO ACTION") return normalized;
+	}
+	parseUnique(line) {
+		const match = line.match(/(?:CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?\s+)?UNIQUE\s*\(([^)]+)\)/i);
+		if (!match) return null;
+		return {
+			type: "unique",
+			name: match[1] ? this.cleanIdentifier(match[1]) : void 0,
+			columns: match[2].split(",").map((c) => this.cleanIdentifier(c.trim()))
+		};
+	}
+	parseCheck(line) {
+		const match = line.match(/(?:CONSTRAINT\s+["'`]?([^"'`\s]+)["'`"]?\s+)?CHECK\s*\(([\s\S]*?)\)/i);
+		if (!match) return null;
+		return {
+			type: "check",
+			name: match[1] ? this.cleanIdentifier(match[1]) : void 0,
+			expression: match[2].trim()
+		};
+	}
+	parseIndex(line) {
+		var _match$3;
+		const match = line.match(/(UNIQUE\s+)?(?:INDEX|KEY)\s+["'`]?([^"'`\s]+)["'`"]?\s*\(([^)]+)\)(?:\s+USING\s+(\w+))?/i);
+		if (!match) return null;
+		const unique = !!match[1];
+		const name = this.cleanIdentifier(match[2]);
+		const columnsStr = match[3];
+		const method = (_match$3 = match[4]) === null || _match$3 === void 0 ? void 0 : _match$3.toLowerCase();
+		return {
+			type: "index",
+			name,
+			columns: columnsStr.split(",").map((col) => {
+				var _ref5, _ref6, _ref7, _ref8, _colMatch$, _colMatch$2;
+				const colMatch = col.trim().match(/^(?:`([^`]+)`|"([^"]+)"|'([^']+)'|\[([^\]]+)\]|([^\s(]+))(?:\((\d+)\))?(?:\s+(ASC|DESC))?$/i);
+				if (!colMatch) return { name: this.cleanIdentifier(col.trim()) };
+				return {
+					name: this.cleanIdentifier((_ref5 = (_ref6 = (_ref7 = (_ref8 = (_colMatch$ = colMatch[1]) !== null && _colMatch$ !== void 0 ? _colMatch$ : colMatch[2]) !== null && _ref8 !== void 0 ? _ref8 : colMatch[3]) !== null && _ref7 !== void 0 ? _ref7 : colMatch[4]) !== null && _ref6 !== void 0 ? _ref6 : colMatch[5]) !== null && _ref5 !== void 0 ? _ref5 : ""),
+					length: colMatch[6] ? Number(colMatch[6]) : void 0,
+					order: (_colMatch$2 = colMatch[7]) === null || _colMatch$2 === void 0 ? void 0 : _colMatch$2.toUpperCase()
+				};
+			}),
+			unique,
+			method
+		};
+	}
+	parseTableOptions(optionsStr) {
+		if (!optionsStr.trim()) return void 0;
+		const options = {};
+		const engineMatch = optionsStr.match(/ENGINE\s*=\s*(\w+)/i);
+		if (engineMatch) options.engine = engineMatch[1];
+		const charsetMatch = optionsStr.match(/(?:DEFAULT\s+)?(?:CHARACTER\s+SET|CHARSET)\s*=?\s*([^\s;]+)/i);
+		if (charsetMatch) options.charset = this.cleanIdentifier(charsetMatch[1]);
+		const collateMatch = optionsStr.match(/COLLATE\s*=?\s*([^\s;]+)/i);
+		if (collateMatch) options.collation = this.cleanIdentifier(collateMatch[1]);
+		const autoIncMatch = optionsStr.match(/AUTO_INCREMENT\s*=\s*(\d+)/i);
+		if (autoIncMatch) options.autoIncrement = Number(autoIncMatch[1]);
+		const commentMatch = optionsStr.match(/COMMENT\s*=\s*['"]([^'"]+)['"]/i);
+		if (commentMatch) options.comment = commentMatch[1];
+		return Object.keys(options).length > 0 ? options : void 0;
+	}
+};
+function mergeComponentFields(prev, next) {
+	if (prev === void 0 && next === void 0) return;
+	const prevFields = prev !== null && prev !== void 0 ? prev : [];
+	const nextFields = next !== null && next !== void 0 ? next : [];
+	const prevFieldsMap = getFieldDataMap(prevFields);
+	const updated = nextFields.map((field) => {
+		const prevData = prevFieldsMap[field.label];
+		if (!prevData) return field;
+		return _objectSpread2(_objectSpread2({}, field), {}, { data: prevData });
+	});
+	const missingFields = prevFields.filter((field) => !nextFields.some((f) => f.label === field.label));
+	return [...updated, ...missingFields];
+}
+function getFieldDataMap(fields) {
+	const result = {};
+	for (const field of fields) result[field.label] = field.data;
+	return result;
+}
+function syncBaseData(prev, next, options) {
+	const updated = {
+		nodes: next.nodes.map((nextNode) => {
+			var _prevNode$width, _prevNode$height, _prevNode$position, _prevNode$data, _nextNode$data;
+			const prevNode = prev.nodes.find((n) => n.id === nextNode.id);
+			if (!prevNode) return nextNode;
+			return _objectSpread2(_objectSpread2(_objectSpread2({}, prevNode), nextNode), {}, {
+				width: (options === null || options === void 0 ? void 0 : options.includeNodeDimensions) ? (_prevNode$width = prevNode.width) !== null && _prevNode$width !== void 0 ? _prevNode$width : nextNode.width : nextNode.width,
+				height: (options === null || options === void 0 ? void 0 : options.includeNodeDimensions) ? (_prevNode$height = prevNode.height) !== null && _prevNode$height !== void 0 ? _prevNode$height : nextNode.height : nextNode.height,
+				position: (options === null || options === void 0 ? void 0 : options.includeNodePositions) ? (_prevNode$position = prevNode.position) !== null && _prevNode$position !== void 0 ? _prevNode$position : nextNode.position : nextNode.position,
+				data: _objectSpread2(_objectSpread2(_objectSpread2({}, prevNode.data), nextNode.data), {}, { componentFields: mergeComponentFields((_prevNode$data = prevNode.data) === null || _prevNode$data === void 0 ? void 0 : _prevNode$data.componentFields, (_nextNode$data = nextNode.data) === null || _nextNode$data === void 0 ? void 0 : _nextNode$data.componentFields) })
+			});
+		}),
+		edges: next.edges.map((nextEdge) => {
+			var _prevEdge$data, _nextEdge$data;
+			const prevEdge = prev.edges.find((e) => e.id === nextEdge.id);
+			if (!prevEdge) return nextEdge;
+			return _objectSpread2(_objectSpread2(_objectSpread2({}, prevEdge), nextEdge), {}, { data: _objectSpread2(_objectSpread2(_objectSpread2({}, prevEdge.data), nextEdge.data), {}, { componentFields: mergeComponentFields((_prevEdge$data = prevEdge.data) === null || _prevEdge$data === void 0 ? void 0 : _prevEdge$data.componentFields, (_nextEdge$data = nextEdge.data) === null || _nextEdge$data === void 0 ? void 0 : _nextEdge$data.componentFields) }) });
+		})
+	};
+	if (options === null || options === void 0 ? void 0 : options.keepPrev) {
+		const missingNodes = prev.nodes.filter((n) => {
+			var _n$data;
+			if (((_n$data = n.data) === null || _n$data === void 0 ? void 0 : _n$data.source) === "mermaid") return false;
+			return !updated.nodes.some((n2) => n2.id === n.id);
+		});
+		const missingEdges = prev.edges.filter((e) => {
+			var _e$data;
+			if (((_e$data = e.data) === null || _e$data === void 0 ? void 0 : _e$data.source) === "mermaid") return false;
+			return !updated.edges.some((e2) => e2.id === e.id);
+		});
+		updated.nodes = [...missingNodes, ...updated.nodes];
+		updated.edges = [...missingEdges, ...updated.edges];
+	}
+	return updated;
+}
+function sanitizeMermaidLabels(src) {
+	if (!src) return src;
+	const subgraphFixed = src.replace(/([A-Za-z0-9_]+)\[((?:(?![\"']).)*?)\]/g, (m, id, label) => {
+		if (/^[\"']/.test(label)) return m;
+		if (/[()\"\[\],:;]/.test(label)) return `${id}[\"${String(label).replace(/\\/g, "\\\\").replace(/\"/g, "\\\"")}\"]`;
+		return m;
+	}).replace(/^([ \t]*subgraph\s+)([^\n\r]+)(\|[^\n\r]*)?$/gim, (m, pre, title, rest) => {
+		const t = String(title).trim();
+		if (/^[\"']/.test(t)) return m;
+		if (/[()\"\[\],:;]/.test(t)) return `${pre}\"${t.replace(/\\/g, "\\\\").replace(/\"/g, "\\\"")}\"${rest || ""}`;
+		return m;
+	});
+	const diagRegex = /\b(graph|flowchart|sequenceDiagram|stateDiagram|classDiagram|gantt|journey|erDiagram|gitGraph|pie|timeline|infoDiagram)\b/i;
+	const allStarts = [];
+	let mm;
+	const globalRegex = new RegExp(diagRegex.source, "gim");
+	while ((mm = globalRegex.exec(subgraphFixed)) !== null) {
+		allStarts.push(mm.index);
+		if (globalRegex.lastIndex === mm.index) globalRegex.lastIndex++;
+	}
+	if (allStarts.length <= 1) return subgraphFixed;
+	const first = allStarts[0];
+	const second = allStarts[1];
+	return subgraphFixed.slice(first, second).trim();
+}
+function flattenMetaData(fields, fieldsValues) {
+	const output = {};
+	fields.forEach((field) => {
+		var _fieldsValues$find;
+		const data = (_fieldsValues$find = fieldsValues.find((f) => (f === null || f === void 0 ? void 0 : f.componentFieldId) === field.componentFieldId)) === null || _fieldsValues$find === void 0 ? void 0 : _fieldsValues$find.data;
+		const id = field.componentFieldId;
+		if (!id) return;
+		switch (field.type) {
+			case ComponentInputType.TextInput:
+			case ComponentInputType.TextBox:
+			case ComponentInputType.DropdownSelect:
+			case ComponentInputType.SearchSelect:
+			case ComponentInputType.CodeEditor:
+			case ComponentInputType.URLInput:
+			case ComponentInputType.ColorPicker:
+			case ComponentInputType.DatePicker:
+				var _data$0$value, _data$;
+				output[id] = String((_data$0$value = data === null || data === void 0 || (_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$.value) !== null && _data$0$value !== void 0 ? _data$0$value : "");
+				break;
+			case ComponentInputType.MultiSelect:
+			case ComponentInputType.CheckboxGroup:
+			case ComponentInputType.TagInput:
+				var _data$0$value2, _data$2;
+				output[id] = (_data$0$value2 = data === null || data === void 0 || (_data$2 = data[0]) === null || _data$2 === void 0 ? void 0 : _data$2.value) !== null && _data$0$value2 !== void 0 ? _data$0$value2 : [];
+				break;
+			case ComponentInputType.NumberInput:
+			case ComponentInputType.Slider:
+				var _data$3;
+				output[id] = (data === null || data === void 0 || (_data$3 = data[0]) === null || _data$3 === void 0 ? void 0 : _data$3.value) ? Number(data[0].value) : null;
+				break;
+			case ComponentInputType.FileUpload:
+			case ComponentInputType.LinkOrFileUpload:
+				var _data$0$value3, _data$4;
+				output[id] = (_data$0$value3 = data === null || data === void 0 || (_data$4 = data[0]) === null || _data$4 === void 0 ? void 0 : _data$4.value) !== null && _data$0$value3 !== void 0 ? _data$0$value3 : "";
+				break;
+			case ComponentInputType.RichTextEditor:
+				var _data$5;
+				output[id] = (_data$5 = data === null || data === void 0 ? void 0 : data[0]) !== null && _data$5 !== void 0 ? _data$5 : void 0;
+				break;
+			case ComponentInputType.KeyValueList:
+				output[id] = data !== null && data !== void 0 ? data : [];
+				break;
+			case ComponentInputType.BooleanToggle:
+				var _data$0$value4, _data$6;
+				output[id] = (_data$0$value4 = data === null || data === void 0 || (_data$6 = data[0]) === null || _data$6 === void 0 ? void 0 : _data$6.value) !== null && _data$0$value4 !== void 0 ? _data$0$value4 : false;
+				break;
+			case ComponentInputType.DateRangePicker:
+				output[id] = data === null || data === void 0 ? void 0 : data[0];
+				break;
+		}
+	});
+	return output;
+}
+function buildMetaData(fields, data) {
+	return fields.map((field) => {
+		var _field$type, _field$required, _field$label, _field$order, _localData;
+		let localData;
+		const value = data[field.componentFieldId];
+		switch (field.type) {
+			case ComponentInputType.TextInput:
+			case ComponentInputType.TextBox:
+			case ComponentInputType.DropdownSelect:
+			case ComponentInputType.SearchSelect:
+			case ComponentInputType.CodeEditor:
+			case ComponentInputType.URLInput:
+			case ComponentInputType.ColorPicker:
+			case ComponentInputType.DatePicker:
+				localData = [{ value: String(value !== null && value !== void 0 ? value : "") }];
+				break;
+			case ComponentInputType.MultiSelect:
+			case ComponentInputType.CheckboxGroup:
+			case ComponentInputType.TagInput:
+				localData = [{ value: value !== null && value !== void 0 ? value : [] }];
+				break;
+			case ComponentInputType.NumberInput:
+			case ComponentInputType.Slider:
+				localData = [{ value: value != null ? Number(value) : null }];
+				break;
+			case ComponentInputType.FileUpload:
+			case ComponentInputType.LinkOrFileUpload:
+				localData = [{ value: value !== null && value !== void 0 ? value : "" }];
+				break;
+			case ComponentInputType.RichTextEditor:
+				localData = [value];
+				break;
+			case ComponentInputType.KeyValueList:
+				localData = value !== null && value !== void 0 ? value : [];
+				break;
+			case ComponentInputType.BooleanToggle:
+				localData = [{ value: value !== null && value !== void 0 ? value : false }];
+				break;
+			case ComponentInputType.DateRangePicker:
+				localData = [value];
+				break;
+			default:
+				localData = value !== null && value !== void 0 ? value : null;
+				break;
+		}
+		return _objectSpread2(_objectSpread2({}, field), {}, {
+			componentFieldId: field.componentFieldId,
+			type: (_field$type = field.type) !== null && _field$type !== void 0 ? _field$type : ComponentInputType.TextInput,
+			required: (_field$required = field.required) !== null && _field$required !== void 0 ? _field$required : false,
+			label: (_field$label = field.label) !== null && _field$label !== void 0 ? _field$label : "",
+			order: (_field$order = field.order) !== null && _field$order !== void 0 ? _field$order : 0,
+			data: (_localData = localData) !== null && _localData !== void 0 ? _localData : []
+		});
+	});
+}
+function generateComponentFieldInput(options) {
+	var _options$componentFie;
+	const componentId = (_options$componentFie = options.componentFieldId) !== null && _options$componentFie !== void 0 ? _options$componentFie : String(Math.random());
+	const [metaData] = buildMetaData([_objectSpread2(_objectSpread2({}, options), {}, {
+		hidden: true,
+		componentFieldId: componentId
+	})], { [componentId]: options.type === ComponentInputType.RichTextEditor && typeof options.data === "string" ? markdownToDelta(options.data) : options.data });
+	return metaData;
+}
+function generateComponentFieldNameInput(value) {
+	return generateComponentFieldInput({
+		componentFieldId: "name",
+		label: "Name",
+		type: ComponentInputType.TextInput,
+		data: value
+	});
+}
+function getComponentFieldByLabel(fields, label) {
+	return fields.find((field) => {
+		var _field$label;
+		return ((_field$label = field.label) === null || _field$label === void 0 ? void 0 : _field$label.toLowerCase()) === label.toLowerCase();
+	});
+}
+const LAYOUT_SPACING = {
+	SUBGRAPH_HEADER_HEIGHT: 35,
+	SUBGRAPH_PADDING: 8,
+	SUBGRAPH_CONTENT_TOP_MARGIN: 10,
+	NODE_SEPARATION_HORIZONTAL: 80,
+	NODE_SEPARATION_VERTICAL: 100,
+	CONTAINER_SEPARATION_HORIZONTAL: 120,
+	CONTAINER_SEPARATION_VERTICAL: 160,
+	NESTED_SUBGRAPH_SEPARATION_HORIZONTAL: 120,
+	NESTED_SUBGRAPH_SEPARATION_VERTICAL: 140,
+	META_GRAPH_MARGIN: 100,
+	NESTED_CONTENT_MARGIN: 40,
+	MIXED_CONTENT_VERTICAL_SPACING: 100,
+	MIXED_CONTENT_HORIZONTAL_SPACING: 120
+};
+({
+	NETWORK_SIMPLEX: "network-simplex",
+	TIGHT_TREE: "tight-tree",
+	LONGEST_PATH: "longest-path"
+}).TIGHT_TREE;
+const SEQUENCE_LAYOUT = {
+	COLUMN_WIDTH: 360,
+	ROW_HEIGHT: 60,
+	HEADER_HEIGHT: 40,
+	MESSAGE_NODE_WIDTH: 120,
+	MESSAGE_NODE_HEIGHT: 36,
+	SELF_LOOP_OFFSET: 80,
+	PARTICIPANT_NODE_WIDTH: 10
+};
+const LABEL_TYPE_PREFIX = /^\s*type:(\w+)\s*[:|-]\s*/i;
+const TAG_TO_NODE_TYPE = {
+	builder: "builder",
+	code: "code",
+	text: "text",
+	table: "table",
+	image: "image",
+	cloud: "cloud",
+	comment: "comment",
+	default: "default"
+};
+function parseLabelTag(label) {
+	const match = label.match(LABEL_TYPE_PREFIX);
+	if (match) return {
+		tag: match[1].toLowerCase(),
+		displayLabel: label.slice(match[0].length).trim()
+	};
+	return {
+		tag: null,
+		displayLabel: label
+	};
+}
+function resolvePortalNodeType(hasImageUrl, tag) {
+	if (hasImageUrl || tag === "image") return "image";
+	if (tag && TAG_TO_NODE_TYPE[tag]) return TAG_TO_NODE_TYPE[tag];
+	return "shape";
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n$1) {
+		e(n$1);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n$1) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n$1);
+			}
+			function _throw(n$1) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n$1);
+			}
+			_next(void 0);
+		});
+	};
+}
+mermaid.initialize({
+	startOnLoad: false,
+	theme: "default",
+	flowchart: {
+		htmlLabels: false,
+		curve: "linear"
+	}
+});
+function detectDiagramType(code) {
+	const lines = code.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim().toLowerCase();
+		if (trimmed.startsWith("sequencediagram")) return "sequence";
+		if (trimmed.startsWith("flowchart") || trimmed.startsWith("graph")) return "flowchart";
+	}
+	return "flowchart";
+}
+function parseSequenceDiagram(code) {
+	const participants = [];
+	const messages = [];
+	const participantMap = /* @__PURE__ */ new Map();
+	const lines = code.split("\n");
+	let messageRow = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.toLowerCase() === "sequencediagram") continue;
+		const participantMatch = trimmed.match(/^(?:participant|actor)\s+(\S+)(?:\s+as\s+(.+))?$/i);
+		if (participantMatch) {
+			var _participantMatch$;
+			const id = participantMatch[1];
+			const alias = (_participantMatch$ = participantMatch[2]) === null || _participantMatch$ === void 0 ? void 0 : _participantMatch$.trim();
+			if (!participantMap.has(id)) {
+				const index = participants.length;
+				participantMap.set(id, index);
+				participants.push({
+					id,
+					name: alias !== null && alias !== void 0 ? alias : id,
+					alias,
+					index
+				});
+			}
+			continue;
+		}
+		const messageMatch = trimmed.match(/^([A-Za-z0-9_]+)\s*(-->>|-->|--\)|->>|->|-\))\s*([A-Za-z0-9_]+)\s*:\s*(.*)$/);
+		if (messageMatch) {
+			const [, from, arrow, to, label] = messageMatch;
+			if (!participantMap.has(from)) {
+				const index = participants.length;
+				participantMap.set(from, index);
+				participants.push({
+					id: from,
+					name: from,
+					index
+				});
+			}
+			if (!participantMap.has(to)) {
+				const index = participants.length;
+				participantMap.set(to, index);
+				participants.push({
+					id: to,
+					name: to,
+					index
+				});
+			}
+			const lineStyle = arrow.startsWith("--") ? "dashed" : "solid";
+			const arrowType = arrow.includes(">>") ? "filled" : arrow.includes(")") ? "open" : "none";
+			messages.push({
+				from,
+				to,
+				label: label.trim(),
+				lineStyle,
+				arrowType,
+				rowIndex: messageRow++
+			});
+		}
+	}
+	return {
+		participants,
+		messages
+	};
+}
+const MERMAID_TO_PORTAL_SHAPE = {
+	rect: "rectangle",
+	round: "rounded-rect",
+	stadium: "terminator",
+	circle: "ellipse",
+	diamond: "diamond"
+};
+const SUBGRAPH_HEADER_HEIGHT = LAYOUT_SPACING.SUBGRAPH_HEADER_HEIGHT;
+const SUBGRAPH_PADDING = LAYOUT_SPACING.SUBGRAPH_PADDING;
+const SUBGRAPH_CONTENT_TOP_MARGIN = LAYOUT_SPACING.SUBGRAPH_CONTENT_TOP_MARGIN;
+const NODE_SEPARATION_HORIZONTAL = LAYOUT_SPACING.NODE_SEPARATION_HORIZONTAL;
+const NODE_SEPARATION_VERTICAL = LAYOUT_SPACING.NODE_SEPARATION_VERTICAL;
+const CONTAINER_SEPARATION_HORIZONTAL = LAYOUT_SPACING.CONTAINER_SEPARATION_HORIZONTAL;
+const CONTAINER_SEPARATION_VERTICAL = LAYOUT_SPACING.CONTAINER_SEPARATION_VERTICAL;
+const NESTED_SUBGRAPH_SEPARATION_HORIZONTAL = LAYOUT_SPACING.NESTED_SUBGRAPH_SEPARATION_HORIZONTAL;
+const NESTED_SUBGRAPH_SEPARATION_VERTICAL = LAYOUT_SPACING.NESTED_SUBGRAPH_SEPARATION_VERTICAL;
+const META_GRAPH_MARGIN = LAYOUT_SPACING.META_GRAPH_MARGIN;
+const NESTED_CONTENT_MARGIN = LAYOUT_SPACING.NESTED_CONTENT_MARGIN;
+const MIXED_CONTENT_VERTICAL_SPACING = LAYOUT_SPACING.MIXED_CONTENT_VERTICAL_SPACING;
+const MIXED_CONTENT_HORIZONTAL_SPACING = LAYOUT_SPACING.MIXED_CONTENT_HORIZONTAL_SPACING;
+const DAGRE_RANKER = "tight-tree";
+const DEBUG = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DEBUG_MERMAID === "true";
+function debugLog(...args) {
+	if (DEBUG) console.log("[MermaidConverter]", ...args);
+}
+function getNodeShape(nodeDefinition) {
+	if (nodeDefinition.includes("{") && nodeDefinition.includes("}")) return "diamond";
+	if (nodeDefinition.includes("((") && nodeDefinition.includes("))")) return "circle";
+	if (nodeDefinition.includes("([") && nodeDefinition.includes("])")) return "stadium";
+	if (nodeDefinition.includes("[") && nodeDefinition.includes("]")) return "rect";
+	if (nodeDefinition.includes("(") && nodeDefinition.includes(")")) return "round";
+	return "rect";
+}
+function parseMermaidCode(code) {
+	const nodes = [];
+	const edges = [];
+	const subgraphs = [];
+	const nodeMap = /* @__PURE__ */ new Map();
+	const subgraphMap = /* @__PURE__ */ new Map();
+	const nodeDefinitions = /* @__PURE__ */ new Map();
+	let direction = "TB";
+	let cleanCode = code.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("%%")).join("\n");
+	const preprocessedLines = [];
+	const rawLines = cleanCode.split("\n");
+	let i = 0;
+	while (i < rawLines.length) {
+		const line = rawLines[i].trim();
+		const openBrackets = (line.match(/[\[\(\{]/g) || []).length;
+		const closeBrackets = (line.match(/[\]\)\}]/g) || []).length;
+		if (openBrackets > closeBrackets && i < rawLines.length - 1) {
+			let combinedLine = line;
+			let j = i + 1;
+			let currentOpenBrackets = openBrackets;
+			let currentCloseBrackets = closeBrackets;
+			while (j < rawLines.length && currentOpenBrackets > currentCloseBrackets) {
+				const nextLine = rawLines[j].trim();
+				combinedLine += " " + nextLine;
+				currentOpenBrackets += (nextLine.match(/[\[\(\{]/g) || []).length;
+				currentCloseBrackets += (nextLine.match(/[\]\)\}]/g) || []).length;
+				j++;
+			}
+			preprocessedLines.push(combinedLine);
+			i = j;
+		} else {
+			preprocessedLines.push(line);
+			i++;
+		}
+	}
+	cleanCode = preprocessedLines.join("\n");
+	debugLog("Clean code:", cleanCode);
+	const directionMatch = cleanCode.match(/(?:flowchart|graph)\s+(TB|TD|BT|RL|LR)/i);
+	if (directionMatch) {
+		direction = directionMatch[1].toUpperCase();
+		if (direction === "TD") direction = "TB";
+		debugLog("Detected graph direction:", direction);
+	}
+	const lines = cleanCode.split("\n");
+	const subgraphStack = [];
+	function enhancedCleanLabel(label) {
+		return label.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]*>/g, "").replace(/\\u([0-9a-fA-F]{4})/g, (match, code$1) => {
+			try {
+				return String.fromCharCode(parseInt(code$1, 16));
+			} catch (_unused) {
+				debugLog(`Warning: Could not parse unicode character: ${match}`);
+				return match;
+			}
+		}).replace(/\\n/g, "\n").replace(/\s*\n\s*/g, "\n").trim();
+	}
+	debugLog("Pre-scanning for node definitions...");
+	lines.forEach((line, lineIndex) => {
+		const trimmedLine = line.trim();
+		if (!trimmedLine || trimmedLine.startsWith("subgraph") || trimmedLine === "end" || trimmedLine.startsWith("%%")) return;
+		const nodeDefPattern = /(^|[\s\-\>]|\|[^|]*\|)([A-Za-z0-9_]+)([\[\(\{])/g;
+		let match;
+		const processedMatches = /* @__PURE__ */ new Set();
+		while ((match = nodeDefPattern.exec(trimmedLine)) !== null) {
+			const prefix = match[1];
+			const nodeId = match[2];
+			const openChar = match[3];
+			const matchStart = match.index + prefix.length;
+			if (processedMatches.has(matchStart) || nodeDefinitions.has(nodeId)) continue;
+			processedMatches.add(matchStart);
+			const openIndex = matchStart + nodeId.length;
+			const closeChar = openChar === "[" ? "]" : openChar === "(" ? ")" : "}";
+			let closeIndex = -1;
+			let depth = 0;
+			for (let i$1 = openIndex; i$1 < trimmedLine.length; i$1++) {
+				const char = trimmedLine[i$1];
+				if (char === openChar) depth++;
+				else if (char === closeChar) {
+					depth--;
+					if (depth === 0) {
+						closeIndex = i$1;
+						break;
+					}
+				}
+			}
+			let fullDef = nodeId;
+			let shapeDef = "";
+			if (closeIndex !== -1) {
+				fullDef = trimmedLine.slice(matchStart, closeIndex + 1);
+				shapeDef = trimmedLine.slice(openIndex, closeIndex + 1);
+			} else {
+				const fallback = trimmedLine.slice(matchStart).match(/([A-Za-z0-9_]+)([\[\(\{][^\]\)\}]*[\]\)\}])/);
+				if (fallback && fallback[1] === nodeId) {
+					fullDef = fallback[0];
+					shapeDef = fallback[2];
+				}
+			}
+			if (shapeDef) {
+				const shape = getNodeShape(fullDef);
+				let rawLabel = nodeId;
+				const labelContentMatch = shapeDef.match(new RegExp("^[\\[\\(\\{](.*)[\\]\\)\\}]$", "s"));
+				if (labelContentMatch) {
+					rawLabel = labelContentMatch[1];
+					rawLabel = rawLabel.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+				}
+				const label = enhancedCleanLabel(rawLabel);
+				nodeDefinitions.set(nodeId, {
+					label,
+					shape,
+					fullDef
+				});
+				debugLog(`Pre-scan found node definition: ${nodeId} -> "${label}" (${shape}) from line ${lineIndex + 1}`);
+			}
+		}
+	});
+	debugLog("First pass: identifying subgraphs...");
+	for (let i$1 = 0; i$1 < lines.length; i$1++) {
+		const line = lines[i$1].trim();
+		if (!line) continue;
+		if (line.startsWith("subgraph")) {
+			const rest = line.slice(8).trim();
+			let subgraphId;
+			let subgraphTitle;
+			const quoteMatch = rest.match(/^(["'])(.*?)\1/);
+			if (quoteMatch) {
+				subgraphTitle = quoteMatch[2];
+				subgraphId = subgraphTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || `sg-${i$1}`;
+			} else {
+				const bracketMatch = rest.match(/^([^\s\[]+)(?:\s*\[(.+?)\])?/);
+				if (bracketMatch) {
+					subgraphId = bracketMatch[1];
+					if (bracketMatch[2]) subgraphTitle = bracketMatch[2];
+				}
+				if (!subgraphTitle && rest.indexOf(" ") !== -1) {
+					subgraphTitle = rest;
+					subgraphId = subgraphTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || `sg-${i$1}`;
+				}
+				if (!subgraphTitle) {
+					const altQuote = rest.match(/^[^\s]+\s+(["'])(.*?)\1/);
+					if (altQuote) subgraphTitle = altQuote[2];
+				}
+			}
+			if (subgraphId) {
+				const parentId = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : void 0;
+				const cleanTitle = subgraphTitle ? enhancedCleanLabel(subgraphTitle) : subgraphId;
+				debugLog(`Found subgraph: ${subgraphId}, title: "${cleanTitle}", parent: ${parentId || "none"}`);
+				subgraphStack.push(subgraphId);
+				const newSubgraph = {
+					id: subgraphId,
+					title: cleanTitle,
+					nodes: [],
+					parentId,
+					childrenIds: []
+				};
+				subgraphMap.set(subgraphId, newSubgraph);
+				if (parentId) {
+					const parentSubgraph = subgraphMap.get(parentId);
+					if (parentSubgraph) parentSubgraph.childrenIds.push(subgraphId);
+				}
+				subgraphs.push(newSubgraph);
+			}
+		} else if (line.toLowerCase().startsWith("direction ")) {
+			const dirMatch = line.match(/^direction\s+(TB|TD|BT|RL|LR)$/i);
+			if (dirMatch && subgraphStack.length > 0) {
+				const top = subgraphStack[subgraphStack.length - 1];
+				const sg = subgraphMap.get(top);
+				if (sg) {
+					const d = dirMatch[1].toUpperCase();
+					sg.direction = d === "TD" ? "TB" : d;
+				}
+			}
+		} else if (line === "end" && subgraphStack.length > 0) subgraphStack.pop();
+	}
+	subgraphStack.length = 0;
+	function createOrGetNode(nodeId, currentSubgraph) {
+		if (nodeMap.has(nodeId)) {
+			const existingNode = nodeMap.get(nodeId);
+			if (currentSubgraph && !existingNode.subgraph) {
+				existingNode.subgraph = currentSubgraph;
+				const subgraph = subgraphMap.get(currentSubgraph);
+				if (subgraph && !subgraph.nodes.includes(nodeId)) subgraph.nodes.push(nodeId);
+				debugLog(`Updated existing node ${nodeId} to be part of subgraph ${currentSubgraph}`);
+			}
+			return existingNode;
+		}
+		const nodeDef = nodeDefinitions.get(nodeId);
+		let label;
+		let shape;
+		if (nodeDef) {
+			label = nodeDef.label;
+			shape = nodeDef.shape;
+			debugLog(`Creating node ${nodeId} using pre-scanned definition: "${label}" (${shape})`);
+		} else {
+			label = nodeId;
+			shape = "rect";
+			debugLog(`Creating simple fallback node: ${nodeId}`);
+		}
+		const node = {
+			id: nodeId,
+			label,
+			shape,
+			subgraph: currentSubgraph,
+			parentSubgraph: subgraphStack.length > 1 ? subgraphStack[subgraphStack.length - 2] : void 0
+		};
+		nodes.push(node);
+		nodeMap.set(nodeId, node);
+		if (currentSubgraph) {
+			const subgraph = subgraphMap.get(currentSubgraph);
+			if (subgraph) subgraph.nodes.push(nodeId);
+		}
+		return node;
+	}
+	debugLog("Second pass: processing nodes and edges...");
+	for (let i$1 = 0; i$1 < lines.length; i$1++) {
+		const line = lines[i$1].trim();
+		if (!line) continue;
+		if (line.startsWith("subgraph")) {
+			const rest = line.slice(8).trim();
+			let subgraphId;
+			const quoteMatch = rest.match(/^(?:["'])(.*?)(?:["'])/);
+			if (quoteMatch) subgraphId = quoteMatch[1].toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || `sg-${i$1}`;
+			else {
+				const bracketMatch = rest.match(/^([^\s\[]+)(?:\s*\[(.+?)\])?/);
+				if (bracketMatch) {
+					const idToken = bracketMatch[1];
+					if (bracketMatch[2]) subgraphId = idToken;
+					else if (rest.indexOf(" ") !== -1) subgraphId = rest.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || `sg-${i$1}`;
+					else subgraphId = idToken;
+				}
+			}
+			if (subgraphId) {
+				subgraphStack.push(subgraphId);
+				debugLog(`Entering subgraph: ${subgraphId}, stack: [${subgraphStack.join(", ")}]`);
+				continue;
+			}
+		}
+		if (line === "end") {
+			if (subgraphStack.length > 0) {
+				const exitingSubgraph = subgraphStack[subgraphStack.length - 1];
+				subgraphStack.pop();
+				debugLog(`Exiting subgraph: ${exitingSubgraph}, stack: [${subgraphStack.join(", ")}]`);
+			} else debugLog("Warning: Found \"end\" without matching subgraph start");
+			continue;
+		}
+		if (line.startsWith("direction ") || line.startsWith("flowchart ") || line.startsWith("graph ") || line.startsWith("%%")) {
+			debugLog(`Skipping line: ${line}`);
+			continue;
+		}
+		const currentSubgraph = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : void 0;
+		debugLog(`Processing line: "${line}" in subgraph: ${currentSubgraph || "none"}`);
+		function extractToken(str, startIndex) {
+			const idMatch = str.slice(startIndex).match(/^\s*([A-Za-z0-9_]+)/);
+			if (!idMatch) return null;
+			const id = idMatch[1];
+			const idx = startIndex + idMatch[0].length;
+			const rest = str.slice(idx);
+			const openCharMatch = rest.match(/^[\s]*([\[\(\{])/);
+			if (openCharMatch) {
+				const openChar = openCharMatch[1];
+				const openPos = idx + rest.indexOf(openChar);
+				const closeChar = openChar === "[" ? "]" : openChar === "(" ? ")" : "}";
+				const closePos = str.indexOf(closeChar, openPos + 1);
+				if (closePos !== -1) return {
+					id,
+					full: str.slice(startIndex + idMatch[0].search(/\S/), closePos + 1).trim(),
+					endIndex: closePos + 1
+				};
+			}
+			return {
+				id,
+				full: id,
+				endIndex: idx
+			};
+		}
+		function parseEdge(str) {
+			try {
+				let i$2 = 0;
+				const src = extractToken(str, i$2);
+				if (!src) return null;
+				i$2 = src.endIndex;
+				while (i$2 < str.length && /\s/.test(str[i$2])) i$2++;
+				const arrowHeads = [
+					"-.->",
+					"-->",
+					"==>",
+					"->>",
+					"<->",
+					"-<>",
+					"<-",
+					"->"
+				];
+				let foundArrowIndex = -1;
+				let foundArrow = "";
+				for (const ah of arrowHeads) {
+					const idx = str.indexOf(ah, i$2);
+					if (idx !== -1 && (foundArrowIndex === -1 || idx < foundArrowIndex)) {
+						foundArrowIndex = idx;
+						foundArrow = ah;
+					}
+				}
+				let op = null;
+				let edgeLabel = "";
+				if (foundArrowIndex !== -1) {
+					const between = str.slice(i$2, foundArrowIndex);
+					const prePipeMatch = between.match(/\|(.*?)\|/);
+					if (prePipeMatch) edgeLabel = prePipeMatch[1];
+					else {
+						const inline = between.replace(/^\s*[\-\.=:\~]+\s*/g, "").replace(/\s*[\-\.=:\~]+\s*$/g, "").trim();
+						if (inline) edgeLabel = inline;
+					}
+					op = foundArrow;
+					i$2 = foundArrowIndex + foundArrow.length;
+					while (i$2 < str.length && /\s/.test(str[i$2])) i$2++;
+					if (str[i$2] === "|") {
+						const next = str.indexOf("|", i$2 + 1);
+						if (next !== -1) {
+							edgeLabel = str.slice(i$2 + 1, next);
+							i$2 = next + 1;
+						}
+					}
+				} else {
+					for (const o of [
+						"---",
+						"-.-",
+						"::",
+						":-:",
+						"...",
+						"~",
+						"==="
+					].sort((a, b) => b.length - a.length)) if (str.startsWith(o, i$2)) {
+						op = o;
+						i$2 += o.length;
+						break;
+					}
+					if (!op) return null;
+					while (i$2 < str.length && /\s/.test(str[i$2])) i$2++;
+					if (str[i$2] === "|") {
+						const next = str.indexOf("|", i$2 + 1);
+						if (next !== -1) {
+							edgeLabel = str.slice(i$2 + 1, next);
+							i$2 = next + 1;
+						}
+					}
+				}
+				while (i$2 < str.length && /\s/.test(str[i$2])) i$2++;
+				const tgt = extractToken(str, i$2);
+				if (!tgt) return null;
+				const trailing = str.slice(tgt.endIndex).trimStart();
+				if (!edgeLabel && !trailing.startsWith(":::")) {
+					const colonLabelMatch = trailing.match(/^:\s*(.+)$/);
+					if (colonLabelMatch) edgeLabel = colonLabelMatch[1].trim();
+				}
+				const isReverseArrow = op === "<-";
+				return {
+					sourceId: isReverseArrow ? tgt.id : src.id,
+					sourceFull: isReverseArrow ? tgt.full : src.full,
+					targetId: isReverseArrow ? src.id : tgt.id,
+					targetFull: isReverseArrow ? src.full : tgt.full,
+					edgeType: isReverseArrow ? "->" : op,
+					edgeLabel
+				};
+			} catch (_unused2) {
+				return null;
+			}
+		}
+		const parsedEdge = parseEdge(line);
+		if (!parsedEdge) debugLog(`Line "${line}" did not match edge pattern - checking for standalone nodes`);
+		if (parsedEdge) try {
+			const { sourceId, targetId, edgeType, edgeLabel } = parsedEdge;
+			debugLog(`Found edge: ${sourceId} ${edgeType} ${targetId} with label: "${edgeLabel}" in context: ${currentSubgraph || "global"}`);
+			const isSourceSubgraph = subgraphMap.has(sourceId);
+			const isTargetSubgraph = subgraphMap.has(targetId);
+			debugLog(`Source "${sourceId}" is ${isSourceSubgraph ? "a subgraph" : "a node"}`);
+			debugLog(`Target "${targetId}" is ${isTargetSubgraph ? "a subgraph" : "a node"}`);
+			if (!isSourceSubgraph) {
+				const existingSource = nodeMap.get(sourceId);
+				if (existingSource) debugLog(`Source ${sourceId} already exists in subgraph: ${existingSource.subgraph || "none"}`);
+				else createOrGetNode(sourceId, currentSubgraph);
+			}
+			if (!isTargetSubgraph) {
+				const existingTarget = nodeMap.get(targetId);
+				if (existingTarget) debugLog(`Target ${targetId} already exists in subgraph: ${existingTarget.subgraph || "none"}`);
+				else {
+					const targetSubgraph = currentSubgraph;
+					debugLog(`Creating target ${targetId} with subgraph assignment: ${targetSubgraph || "none"} (current subgraph: ${currentSubgraph || "none"})`);
+					createOrGetNode(targetId, targetSubgraph);
+				}
+			}
+			edges.push({
+				source: sourceId,
+				target: targetId,
+				label: enhancedCleanLabel(edgeLabel),
+				type: edgeType,
+				isSourceSubgraph,
+				isTargetSubgraph
+			});
+			debugLog(`Added edge: ${sourceId} -> ${targetId} (source subgraph: ${isSourceSubgraph}, target subgraph: ${isTargetSubgraph})`);
+		} catch (error) {
+			debugLog(`Error parsing edge: ${line}`, error);
+		}
+		else try {
+			const nodePatterns = [/^([A-Za-z0-9_]+)([\[\(\{][^\]\)\}]*[\]\)\}])/, /^([A-Za-z0-9_]+)$/];
+			let foundStandaloneNode = false;
+			for (const pattern of nodePatterns) {
+				const nodeMatch = line.match(pattern);
+				if (nodeMatch && !nodeMap.has(nodeMatch[1])) {
+					const nodeId = nodeMatch[1];
+					if (subgraphMap.has(nodeId)) {
+						debugLog(`Skipping node creation for ${nodeId} as it's a subgraph`);
+						break;
+					}
+					debugLog(`Found standalone node definition: ${nodeId} in context: ${currentSubgraph || "global"}`);
+					createOrGetNode(nodeId, currentSubgraph);
+					foundStandaloneNode = true;
+					break;
+				}
+			}
+			if (!foundStandaloneNode) debugLog(`Line "${line}" did not match any pattern (edge or standalone node)`);
+		} catch (error) {
+			debugLog(`Error parsing standalone node: ${line}`, error);
+		}
+	}
+	debugLog("=== FINAL VERIFICATION ===");
+	debugLog("Subgraph hierarchy:");
+	subgraphs.forEach((sg) => {
+		debugLog(`- ${sg.id}: "${sg.title}" (parent: ${sg.parentId || "none"}, children: ${sg.childrenIds.join(", ") || "none"}, nodes: ${sg.nodes.length})`);
+	});
+	debugLog("Final node assignments:");
+	nodes.forEach((node) => {
+		debugLog(`- ${node.id}: "${node.label}" in subgraph ${node.subgraph || "none"} (shape: ${node.shape})`);
+	});
+	debugLog("Final edges:");
+	edges.forEach((edge, index) => {
+		debugLog(`- Edge ${index}: ${edge.source} -> ${edge.target} (label: "${edge.label}", type: "${edge.type}")`);
+	});
+	return {
+		nodes,
+		edges,
+		subgraphs,
+		direction
+	};
+}
+function calculateNodeSize(label, shape, isImageNode = false) {
+	if (isImageNode) return {
+		width: 80,
+		height: 80
+	};
+	const lines = label.split("\n");
+	function measureLineWidth(text) {
+		try {
+			if (typeof document !== "undefined") {
+				const ctx = document.createElement("canvas").getContext("2d");
+				if (ctx) {
+					ctx.font = "600 13px -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, sans-serif";
+					return ctx.measureText(text).width;
+				}
+			}
+		} catch (_unused3) {}
+		return text.length * 8;
+	}
+	const baseWidth = Math.max(...lines.map((line) => Math.ceil(measureLineWidth(line)))) + 30;
+	const baseHeight = lines.length * 18 + 20;
+	const width = Math.max(80, baseWidth + 30);
+	const height = Math.max(40, baseHeight + 20);
+	if (shape === "diamond") return {
+		width: Math.max(90, Math.ceil(width * 1.05)),
+		height: Math.max(90, Math.ceil(height * 1.05))
+	};
+	if (shape === "circle") {
+		const size = Math.max(width, height) + 10;
+		return {
+			width: size,
+			height: size
+		};
+	}
+	return {
+		width,
+		height
+	};
+}
+function extractImageUrl(label) {
+	const match = label.match(/https?:\/\/[^\s]+\.(jpg|jpeg|png|gif|svg|webp)(\?[^\s]*)?/i);
+	if (match) {
+		const imageUrl = match[0];
+		return {
+			imageUrl,
+			cleanLabel: label.replace(imageUrl, "").trim()
+		};
+	}
+	return {
+		imageUrl: null,
+		cleanLabel: label
+	};
+}
+function processSubgraphsInHierarchicalOrder(subgraphs) {
+	const result = [];
+	const processed = /* @__PURE__ */ new Set();
+	subgraphs.forEach((subgraph) => {
+		if (!subgraph.parentId) {
+			result.push(subgraph);
+			processed.add(subgraph.id);
+		}
+	});
+	let lastProcessedCount = 0;
+	while (processed.size < subgraphs.length && lastProcessedCount !== processed.size) {
+		lastProcessedCount = processed.size;
+		subgraphs.forEach((subgraph) => {
+			if (!processed.has(subgraph.id) && subgraph.parentId && processed.has(subgraph.parentId)) {
+				result.push(subgraph);
+				processed.add(subgraph.id);
+			}
+		});
+	}
+	subgraphs.forEach((subgraph) => {
+		if (!processed.has(subgraph.id)) {
+			debugLog(`Warning: Subgraph ${subgraph.id} has circular reference or missing parent. Adding it anyway.`);
+			result.push(subgraph);
+		}
+	});
+	return result;
+}
+function layoutSubgraphs(nodes, edges, subgraphs, direction) {
+	const subgraphLayouts = /* @__PURE__ */ new Map();
+	const orderedSubgraphs = processSubgraphsInHierarchicalOrder(subgraphs);
+	debugLog(`Laying out ${orderedSubgraphs.length} subgraphs in hierarchical order`);
+	orderedSubgraphs.forEach((subgraph) => {
+		const subgraphNodes = nodes.filter((n) => n.subgraph === subgraph.id);
+		const subgraphEdges = edges.filter((e) => {
+			const sourceNode = nodes.find((n) => n.id === e.source);
+			const targetNode = nodes.find((n) => n.id === e.target);
+			return (sourceNode === null || sourceNode === void 0 ? void 0 : sourceNode.subgraph) === subgraph.id && (targetNode === null || targetNode === void 0 ? void 0 : targetNode.subgraph) === subgraph.id;
+		});
+		debugLog(`Laying out subgraph: ${subgraph.id} with ${subgraphNodes.length} nodes and ${subgraphEdges.length} edges`);
+		const g = new dagre.graphlib.Graph();
+		g.setGraph({
+			rankdir: subgraph.direction || direction,
+			nodesep: NODE_SEPARATION_HORIZONTAL,
+			ranksep: NODE_SEPARATION_VERTICAL,
+			marginx: SUBGRAPH_PADDING,
+			marginy: SUBGRAPH_PADDING + SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN,
+			ranker: DAGRE_RANKER
+		});
+		g.setDefaultEdgeLabel(() => ({}));
+		subgraphNodes.forEach((node) => {
+			const { imageUrl } = extractImageUrl(node.label);
+			const size = calculateNodeSize(node.label, node.shape, !!imageUrl);
+			g.setNode(node.id, {
+				width: size.width,
+				height: size.height
+			});
+		});
+		subgraphEdges.forEach((edge) => {
+			g.setEdge(edge.source, edge.target);
+		});
+		dagre.layout(g);
+		let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+		const nodePositions = /* @__PURE__ */ new Map();
+		subgraphNodes.forEach((node) => {
+			const nodeLayout = g.node(node.id);
+			if (!nodeLayout) {
+				debugLog(`Warning: No layout information for node ${node.id} in subgraph ${subgraph.id}`);
+				return;
+			}
+			const size = calculateNodeSize(node.label, node.shape);
+			nodePositions.set(node.id, {
+				x: nodeLayout.x,
+				y: nodeLayout.y,
+				width: size.width,
+				height: size.height
+			});
+			minX = Math.min(minX, nodeLayout.x - size.width / 2);
+			maxX = Math.max(maxX, nodeLayout.x + size.width / 2);
+			minY = Math.min(minY, nodeLayout.y - size.height / 2);
+			maxY = Math.max(maxY, nodeLayout.y + size.height / 2);
+		});
+		if (subgraphNodes.length === 0 || minX === Infinity || minY === Infinity) {
+			const defaultWidth = 200;
+			const defaultHeight = 100;
+			minX = 0;
+			minY = 0;
+			maxX = defaultWidth;
+			maxY = defaultHeight;
+			debugLog(`Using default dimensions for subgraph ${subgraph.id}: ${defaultWidth}x${defaultHeight}`);
+		}
+		const offsetX = -minX + SUBGRAPH_PADDING;
+		const offsetY = -minY + SUBGRAPH_PADDING + SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN;
+		nodePositions.forEach((pos, nodeId) => {
+			nodePositions.set(nodeId, _objectSpread2(_objectSpread2({}, pos), {}, {
+				x: pos.x + offsetX,
+				y: pos.y + offsetY
+			}));
+		});
+		validateNodeSpacing(nodePositions, subgraph.id);
+		const baseWidth = maxX - minX + SUBGRAPH_PADDING * 2;
+		const baseHeight = maxY - minY + SUBGRAPH_PADDING * 2 + SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN;
+		const width = baseWidth + 4;
+		const height = baseHeight + 4;
+		subgraphLayouts.set(subgraph.id, {
+			id: subgraph.id,
+			title: subgraph.title,
+			nodes: nodePositions,
+			width,
+			height,
+			parentId: subgraph.parentId
+		});
+		debugLog(`Subgraph ${subgraph.id} sizing: base(${baseWidth.toFixed(1)}x${baseHeight.toFixed(1)}) = final(${width.toFixed(1)}x${height.toFixed(1)})`);
+	});
+	recalculateParentSubgraphSizes(subgraphLayouts, orderedSubgraphs, direction);
+	return subgraphLayouts;
+}
+function recalculateParentSubgraphSizes(subgraphLayouts, orderedSubgraphs, direction) {
+	for (let i = orderedSubgraphs.length - 1; i >= 0; i--) {
+		const subgraph = orderedSubgraphs[i];
+		const layout = subgraphLayouts.get(subgraph.id);
+		if (!layout) continue;
+		const childSubgraphs = orderedSubgraphs.filter((sg) => sg.parentId === subgraph.id);
+		if (childSubgraphs.length === 0) continue;
+		let maxContentRight = 0;
+		let maxContentBottom = 0;
+		layout.nodes.forEach((nodePos) => {
+			const nodeRight = nodePos.x + nodePos.width / 2;
+			const nodeBottom = nodePos.y + nodePos.height / 2;
+			maxContentRight = Math.max(maxContentRight, nodeRight);
+			maxContentBottom = Math.max(maxContentBottom, nodeBottom);
+		});
+		const isHorizontal = direction === "LR" || direction === "RL";
+		childSubgraphs.forEach((childSg) => {
+			const childLayout = subgraphLayouts.get(childSg.id);
+			if (childLayout) {
+				const estimatedChildX = isHorizontal ? Math.max(SUBGRAPH_PADDING + childLayout.width / 2, maxContentRight + MIXED_CONTENT_HORIZONTAL_SPACING + childLayout.width / 2) : SUBGRAPH_PADDING + childLayout.width / 2;
+				const estimatedChildY = isHorizontal ? Math.max(SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN + SUBGRAPH_PADDING + childLayout.height / 2, childLayout.height / 2) : Math.max(SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN + SUBGRAPH_PADDING + childLayout.height / 2, maxContentBottom + MIXED_CONTENT_VERTICAL_SPACING + childLayout.height / 2);
+				const childRight = estimatedChildX + childLayout.width / 2;
+				const childBottom = estimatedChildY + childLayout.height / 2;
+				maxContentRight = Math.max(maxContentRight, childRight);
+				maxContentBottom = Math.max(maxContentBottom, childBottom);
+			}
+		});
+		const minRequiredWidth = maxContentRight + SUBGRAPH_PADDING * 3;
+		const minRequiredHeight = maxContentBottom + SUBGRAPH_PADDING * 3;
+		const absoluteMinWidth = 300;
+		const absoluteMinHeight = 200;
+		const finalWidth = Math.max(layout.width, minRequiredWidth, absoluteMinWidth);
+		const finalHeight = Math.max(layout.height, minRequiredHeight, absoluteMinHeight);
+		if (finalWidth > layout.width || finalHeight > layout.height) {
+			const oldWidth = layout.width;
+			const oldHeight = layout.height;
+			layout.width = finalWidth;
+			layout.height = finalHeight;
+			debugLog(`Pre-sized parent ${subgraph.id}: ${oldWidth}x${oldHeight} → ${layout.width}x${layout.height} to contain ${childSubgraphs.length} children + nodes`);
+			childSubgraphs.forEach((child) => {
+				const childLayout = subgraphLayouts.get(child.id);
+				if (childLayout) debugLog(`  Child ${child.id}: ${childLayout.width}x${childLayout.height}`);
+			});
+		}
+	}
+}
+function calculateConnectionWeights(nodes, edges) {
+	const weights = /* @__PURE__ */ new Map();
+	edges.forEach((edge) => {
+		const sourceNode = nodes.find((n) => n.id === edge.source);
+		const targetNode = nodes.find((n) => n.id === edge.target);
+		if (!sourceNode || !targetNode) return;
+		const sourceContainer = sourceNode.subgraph || sourceNode.id;
+		const targetContainer = targetNode.subgraph || targetNode.id;
+		if (sourceContainer === targetContainer) return;
+		if (!weights.has(sourceContainer)) weights.set(sourceContainer, /* @__PURE__ */ new Map());
+		const sourceWeights = weights.get(sourceContainer);
+		const currentWeight = sourceWeights.get(targetContainer) || 0;
+		sourceWeights.set(targetContainer, currentWeight + 1);
+	});
+	return weights;
+}
+function adjustParentSizesAfterPositioning(subgraphLayouts, subgraphPositions, orderedSubgraphs, direction) {
+	const isHorizontal = direction === "LR" || direction === "RL";
+	let changed = true;
+	let iterations = 0;
+	while (changed && iterations < 5) {
+		iterations++;
+		changed = false;
+		orderedSubgraphs.forEach((subgraph) => {
+			const layout = subgraphLayouts.get(subgraph.id);
+			const position = subgraphPositions.get(subgraph.id);
+			if (!layout || !position) return;
+			let maxNodeRight = 0;
+			let maxNodeBottom = SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN + SUBGRAPH_PADDING;
+			layout.nodes.forEach((nodePos) => {
+				const nodeRight = nodePos.x + nodePos.width / 2;
+				const nodeBottom = nodePos.y + nodePos.height / 2;
+				maxNodeRight = Math.max(maxNodeRight, nodeRight);
+				maxNodeBottom = Math.max(maxNodeBottom, nodeBottom);
+			});
+			let maxChildRight = 0;
+			let maxChildBottom = 0;
+			orderedSubgraphs.filter((sg) => sg.parentId === subgraph.id).forEach((child) => {
+				const childLayout = subgraphLayouts.get(child.id);
+				const childPosition = subgraphPositions.get(child.id);
+				if (!childLayout || !childPosition) return;
+				const relX = childPosition.x - position.x;
+				const relY = childPosition.y - position.y;
+				maxChildRight = Math.max(maxChildRight, relX + childLayout.width);
+				maxChildBottom = Math.max(maxChildBottom, relY + childLayout.height);
+			});
+			const contentMaxRight = Math.max(maxNodeRight, maxChildRight);
+			const contentMaxBottom = Math.max(maxNodeBottom, maxChildBottom);
+			const requiredWidth = contentMaxRight + (isHorizontal ? SUBGRAPH_PADDING * 4 : SUBGRAPH_PADDING * 3);
+			const requiredHeight = contentMaxBottom + SUBGRAPH_PADDING * 3;
+			const newWidth = Math.max(layout.width, requiredWidth, isHorizontal ? 600 : 240);
+			const newHeight = Math.max(layout.height, requiredHeight, 200);
+			if (newWidth > layout.width || newHeight > layout.height) {
+				debugLog(`Post-positioning resize (iter ${iterations}): ${subgraph.id} ${layout.width}x${layout.height} → ${newWidth}x${newHeight}`);
+				layout.width = newWidth;
+				layout.height = newHeight;
+				changed = true;
+			}
+		});
+	}
+}
+function getParentNodesBottomBoundary(parentId, parentLayout) {
+	let maxBottom = 0;
+	parentLayout.nodes.forEach((nodePos) => {
+		const nodeBottom = nodePos.y + nodePos.height / 2;
+		maxBottom = Math.max(maxBottom, nodeBottom);
+	});
+	debugLog(`Parent ${parentId} nodes extend to bottom Y=${maxBottom}`);
+	return maxBottom;
+}
+function validateNodeSpacing(nodePositions, subgraphId) {
+	const positions = Array.from(nodePositions.values());
+	let hasOverlap = false;
+	for (let i = 0; i < positions.length; i++) for (let j = i + 1; j < positions.length; j++) {
+		const node1 = positions[i];
+		const node2 = positions[j];
+		const centerDistance = Math.sqrt(Math.pow(node1.x - node2.x, 2) + Math.pow(node1.y - node2.y, 2));
+		const minDistance = (node1.width + node2.width) / 2 + (node1.height + node2.height) / 2 + 20;
+		if (centerDistance < minDistance) {
+			hasOverlap = true;
+			debugLog(`Warning: Potential node overlap in subgraph ${subgraphId} - distance: ${centerDistance.toFixed(1)}, required: ${minDistance.toFixed(1)}`);
+		}
+	}
+	if (!hasOverlap) debugLog(`✓ Node spacing validated for subgraph ${subgraphId} - no overlaps detected`);
+}
+function layoutMetaGraph(nodes, edges, subgraphLayouts, direction) {
+	const g = new dagre.graphlib.Graph();
+	g.setGraph({
+		rankdir: direction,
+		nodesep: CONTAINER_SEPARATION_HORIZONTAL,
+		ranksep: CONTAINER_SEPARATION_VERTICAL,
+		marginx: META_GRAPH_MARGIN,
+		marginy: META_GRAPH_MARGIN,
+		ranker: DAGRE_RANKER
+	});
+	g.setDefaultEdgeLabel(() => ({}));
+	debugLog("Laying out meta-graph");
+	const connectionWeights = calculateConnectionWeights(nodes, edges);
+	subgraphLayouts.forEach((layout, id) => {
+		if (!layout.parentId) {
+			g.setNode(id, {
+				width: layout.width,
+				height: layout.height
+			});
+			debugLog(`Added subgraph ${id} to meta-graph (width=${layout.width}, height=${layout.height})`);
+		}
+	});
+	const standaloneNodes = nodes.filter((n) => !n.subgraph);
+	standaloneNodes.forEach((node) => {
+		const { imageUrl } = extractImageUrl(node.label);
+		const size = calculateNodeSize(node.label, node.shape, !!imageUrl);
+		g.setNode(node.id, {
+			width: size.width,
+			height: size.height
+		});
+		debugLog(`Added standalone node ${node.id} to meta-graph`);
+	});
+	connectionWeights.forEach((targets, sourceId) => {
+		targets.forEach((weight, targetId) => {
+			const sourceLayout = subgraphLayouts.get(sourceId);
+			const targetLayout = subgraphLayouts.get(targetId);
+			if (sourceLayout && sourceLayout.parentId === targetId || targetLayout && targetLayout.parentId === sourceId) return;
+			const sourceIsTopLevel = !sourceLayout || !sourceLayout.parentId;
+			const targetIsTopLevel = !targetLayout || !targetLayout.parentId;
+			if (sourceIsTopLevel && targetIsTopLevel) {
+				if (g.hasNode(sourceId) && g.hasNode(targetId)) {
+					if (!g.hasEdge(sourceId, targetId)) {
+						g.setEdge(sourceId, targetId, { weight });
+						debugLog(`Added meta-edge from ${sourceId} to ${targetId} with weight ${weight}`);
+					}
+				}
+			}
+		});
+	});
+	dagre.layout(g);
+	const subgraphPositions = /* @__PURE__ */ new Map();
+	const standalonePositions = /* @__PURE__ */ new Map();
+	subgraphLayouts.forEach((layout, id) => {
+		if (!layout.parentId) {
+			const node = g.node(id);
+			if (node) {
+				subgraphPositions.set(id, {
+					x: node.x - layout.width / 2,
+					y: node.y - layout.height / 2
+				});
+				debugLog(`Positioned subgraph ${id} at (${node.x - layout.width / 2}, ${node.y - layout.height / 2})`);
+			} else debugLog(`Warning: No position for subgraph ${id} in meta-graph`);
+		}
+	});
+	const processedSubgraphs = /* @__PURE__ */ new Set();
+	function layoutChildrenWithinParent(parentId) {
+		const parentPos = subgraphPositions.get(parentId);
+		const parentLayout = subgraphLayouts.get(parentId);
+		if (!parentPos || !parentLayout) return false;
+		const childIds = [];
+		subgraphLayouts.forEach((layout, id) => {
+			if (layout.parentId === parentId) childIds.push(id);
+		});
+		if (childIds.length === 0) return false;
+		let maxNodeBottom = 0;
+		const parentNodesBottom = getParentNodesBottomBoundary(parentId, parentLayout);
+		if (parentNodesBottom > 0) {
+			maxNodeBottom = parentNodesBottom;
+			debugLog(`Parent ${parentId} has nodes extending to Y=${maxNodeBottom}, will position child subgraphs below this`);
+		}
+		const cg = new dagre.graphlib.Graph();
+		const parentDir = direction;
+		cg.setGraph({
+			rankdir: parentDir,
+			nodesep: NESTED_SUBGRAPH_SEPARATION_HORIZONTAL,
+			ranksep: NESTED_SUBGRAPH_SEPARATION_VERTICAL,
+			marginx: NESTED_CONTENT_MARGIN,
+			marginy: NESTED_CONTENT_MARGIN,
+			ranker: DAGRE_RANKER
+		});
+		cg.setDefaultEdgeLabel(() => ({}));
+		childIds.forEach((cid) => {
+			const cl = subgraphLayouts.get(cid);
+			cg.setNode(cid, {
+				width: cl.width,
+				height: cl.height
+			});
+		});
+		let hasEdges = false;
+		childIds.forEach((sourceId) => {
+			const targets = connectionWeights.get(sourceId);
+			if (!targets) return;
+			targets.forEach((weight, targetId) => {
+				if (childIds.includes(targetId) && !cg.hasEdge(sourceId, targetId)) {
+					cg.setEdge(sourceId, targetId, { weight });
+					hasEdges = true;
+				}
+			});
+		});
+		if (!hasEdges && childIds.length > 1) for (let i = 0; i < childIds.length - 1; i++) cg.setEdge(childIds[i], childIds[i + 1], { weight: 1 });
+		dagre.layout(cg);
+		let minLeft = Infinity, minTop = Infinity, maxRight = -Infinity, maxBottom = -Infinity;
+		const childTopLefts = /* @__PURE__ */ new Map();
+		childIds.forEach((cid) => {
+			const n = cg.node(cid);
+			const cl = subgraphLayouts.get(cid);
+			const left = n.x - cl.width / 2;
+			const top = n.y - cl.height / 2;
+			const right = n.x + cl.width / 2;
+			const bottom = n.y + cl.height / 2;
+			childTopLefts.set(cid, {
+				x: left,
+				y: top
+			});
+			minLeft = Math.min(minLeft, left);
+			minTop = Math.min(minTop, top);
+			maxRight = Math.max(maxRight, right);
+			maxBottom = Math.max(maxBottom, bottom);
+		});
+		let contentOriginX = parentPos.x + SUBGRAPH_PADDING;
+		let contentOriginY = parentPos.y + SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN + SUBGRAPH_PADDING;
+		const isHorizontal = parentDir === "LR" || parentDir === "RL";
+		if (isHorizontal) {
+			const parentNodesMaxRight = Array.from(parentLayout.nodes.values()).reduce((acc, n) => Math.max(acc, n.x + n.width / 2), 0);
+			if (parentNodesMaxRight > 0) {
+				const proposedX = parentPos.x + Math.max(SUBGRAPH_PADDING, parentNodesMaxRight + MIXED_CONTENT_HORIZONTAL_SPACING);
+				contentOriginX = Math.max(contentOriginX, proposedX);
+				debugLog(`Adjusted child subgraph start position to X=${contentOriginX} for LR/RL to avoid parent nodes`);
+			}
+		} else if (maxNodeBottom > 0) {
+			const nodeBottomInParentCoords = maxNodeBottom;
+			const proposedY = parentPos.y + nodeBottomInParentCoords + MIXED_CONTENT_VERTICAL_SPACING;
+			contentOriginY = Math.max(contentOriginY, proposedY);
+			debugLog(`Adjusted child subgraph start position to Y=${contentOriginY} to avoid parent nodes (added ${MIXED_CONTENT_VERTICAL_SPACING}px spacing)`);
+		}
+		const availableWidth = parentLayout.width - SUBGRAPH_PADDING * 2;
+		const usedVerticalSpace = contentOriginY - parentPos.y;
+		const availableHeight = parentLayout.height - usedVerticalSpace - SUBGRAPH_PADDING;
+		const contentWidth = maxRight - minLeft;
+		const contentHeight = maxBottom - minTop;
+		const centerOffsetX = isHorizontal ? Math.max(0, (availableWidth - contentWidth) / 2) : 0;
+		const centerOffsetY = isHorizontal ? 0 : Math.max(0, (availableHeight - contentHeight) / 2);
+		childIds.forEach((cid) => {
+			const tl = childTopLefts.get(cid);
+			const absX = contentOriginX + centerOffsetX + (tl.x - minLeft);
+			const absY = contentOriginY + centerOffsetY + (tl.y - minTop);
+			subgraphPositions.set(cid, {
+				x: absX,
+				y: absY
+			});
+			processedSubgraphs.add(cid);
+			debugLog(`Positioned nested subgraph "${cid}" within parent ${parentId} at (${absX}, ${absY}) with centering`);
+		});
+		const requiredWidth = isHorizontal ? Math.max(contentWidth + SUBGRAPH_PADDING * 6, contentOriginX - parentPos.x + contentWidth + SUBGRAPH_PADDING * 3) : contentWidth + SUBGRAPH_PADDING * 6;
+		const childrenBottomBoundary = contentOriginY + centerOffsetY + (maxBottom - minTop) - parentPos.y;
+		const minRequiredHeight = isHorizontal ? Math.max(SUBGRAPH_HEADER_HEIGHT + SUBGRAPH_CONTENT_TOP_MARGIN + SUBGRAPH_PADDING * 2 + contentHeight + SUBGRAPH_PADDING * 2, 300) : Math.max(childrenBottomBoundary + SUBGRAPH_PADDING * 4, maxNodeBottom + MIXED_CONTENT_VERTICAL_SPACING + contentHeight + SUBGRAPH_PADDING * 4);
+		const finalRequiredWidth = Math.max(requiredWidth, isHorizontal ? 600 : 400);
+		const finalRequiredHeight = Math.max(minRequiredHeight, 300);
+		if (finalRequiredWidth > parentLayout.width || finalRequiredHeight > parentLayout.height) {
+			const oldWidth = parentLayout.width;
+			const oldHeight = parentLayout.height;
+			parentLayout.width = Math.max(parentLayout.width, finalRequiredWidth);
+			parentLayout.height = Math.max(parentLayout.height, finalRequiredHeight);
+			debugLog(`Expanded parent ${parentId} from ${oldWidth}x${oldHeight} to ${parentLayout.width}x${parentLayout.height} to fit nodes + ${childIds.length} child subgraphs (overflow-safe)`);
+		}
+		return true;
+	}
+	const processedParents = /* @__PURE__ */ new Set();
+	let madeProgress = true;
+	let safetyCounter = 0;
+	while (madeProgress && safetyCounter < 100) {
+		safetyCounter++;
+		madeProgress = false;
+		subgraphLayouts.forEach((_, id) => {
+			if (subgraphPositions.has(id) && !processedParents.has(id)) {
+				if (layoutChildrenWithinParent(id)) {
+					madeProgress = true;
+					processedParents.add(id);
+				}
+			}
+		});
+	}
+	if (safetyCounter === 100) debugLog("Warning: nested subgraph layout reached iteration cap; potential cyclic dependency");
+	standaloneNodes.forEach((node) => {
+		const nodeLayout = g.node(node.id);
+		if (nodeLayout) {
+			const size = calculateNodeSize(node.label, node.shape);
+			standalonePositions.set(node.id, {
+				x: nodeLayout.x - size.width / 2,
+				y: nodeLayout.y - size.height / 2
+			});
+			debugLog(`Positioned standalone node ${node.id} at (${nodeLayout.x - size.width / 2}, ${nodeLayout.y - size.height / 2})`);
+		} else debugLog(`Warning: No position for standalone node ${node.id} in meta-graph`);
+	});
+	return {
+		subgraphPositions,
+		standalonePositions
+	};
+}
+function createReactFlowElements(nodes, edges, subgraphs, subgraphLayouts, subgraphPositions, standalonePositions, direction) {
+	const reactFlowNodes = [];
+	debugLog("Creating React Flow elements");
+	function getNodeColors(shape) {
+		const colors = {
+			rect: ["#E3F2FD", "#1976D2"],
+			diamond: ["#FFF3E0", "#F57C00"],
+			circle: ["#E8F5E8", "#388E3C"],
+			stadium: ["#F3E5F5", "#7B1FA2"],
+			round: ["#FCE4EC", "#C2185B"]
+		}[shape] || ["#F0F4F8", "#2D3748"];
+		return {
+			backgroundColor: colors[0],
+			borderColor: colors[1]
+		};
+	}
+	function getSubgraphColors(index) {
+		const subgraphColors = [
+			{
+				bg: "rgba(227, 242, 253, 0.4)",
+				border: "#1976D2"
+			},
+			{
+				bg: "rgba(232, 245, 233, 0.4)",
+				border: "#388E3C"
+			},
+			{
+				bg: "rgba(243, 229, 245, 0.4)",
+				border: "#7B1FA2"
+			},
+			{
+				bg: "rgba(255, 243, 224, 0.4)",
+				border: "#F57C00"
+			},
+			{
+				bg: "rgba(252, 228, 236, 0.4)",
+				border: "#C2185B"
+			}
+		];
+		return subgraphColors[index % subgraphColors.length];
+	}
+	processSubgraphsInHierarchicalOrder(subgraphs).forEach((subgraph, index) => {
+		const layout = subgraphLayouts.get(subgraph.id);
+		const position = subgraphPositions.get(subgraph.id);
+		if (layout && position) {
+			const colors = getSubgraphColors(index);
+			let finalPosition = position;
+			if (layout.parentId) {
+				const parentAbsPos = subgraphPositions.get(layout.parentId);
+				if (parentAbsPos) finalPosition = {
+					x: position.x - parentAbsPos.x,
+					y: position.y - parentAbsPos.y
+				};
+			}
+			reactFlowNodes.push({
+				id: `subgraph-${subgraph.id}`,
+				type: "group",
+				position: finalPosition,
+				data: {
+					backgroundColor: colors.bg,
+					borderColor: colors.border,
+					childNodes: subgraph.nodes,
+					componentFields: [generateComponentFieldNameInput(subgraph.title)]
+				},
+				style: {
+					width: layout.width,
+					height: layout.height,
+					zIndex: 0
+				},
+				selectable: true,
+				draggable: true,
+				connectable: true,
+				parentId: layout.parentId ? `subgraph-${layout.parentId}` : void 0,
+				extent: layout.parentId ? "parent" : void 0,
+				zIndex: layout.parentId ? 1 : 0
+			});
+		}
+	});
+	nodes.forEach((node) => {
+		const colors = getNodeColors(node.shape);
+		const { imageUrl, cleanLabel } = extractImageUrl(node.label);
+		const { tag, displayLabel } = parseLabelTag(cleanLabel);
+		const portalType = resolvePortalNodeType(!!imageUrl, tag);
+		let position;
+		let parentNode;
+		if (node.subgraph) {
+			const subgraphLayout = subgraphLayouts.get(node.subgraph);
+			const subgraphPosition = subgraphPositions.get(node.subgraph);
+			const nodeLayout = subgraphLayout === null || subgraphLayout === void 0 ? void 0 : subgraphLayout.nodes.get(node.id);
+			if (nodeLayout && subgraphPosition) {
+				position = {
+					x: nodeLayout.x - nodeLayout.width / 2,
+					y: nodeLayout.y - nodeLayout.height / 2
+				};
+				parentNode = `subgraph-${node.subgraph}`;
+				debugLog(`Node ${node.id} positioned at (${position.x}, ${position.y}) within subgraph ${node.subgraph}`);
+			} else {
+				position = {
+					x: 0,
+					y: 0
+				};
+				debugLog(`Warning: Missing layout data for node ${node.id} in subgraph ${node.subgraph}`);
+			}
+		} else {
+			position = standalonePositions.get(node.id) || {
+				x: 0,
+				y: 0
+			};
+			debugLog(`Standalone node ${node.id} positioned at (${position.x}, ${position.y})`);
+		}
+		const isHorizontal = direction === "LR" || direction === "RL";
+		const sourcePos = isHorizontal ? Position.Right : Position.Bottom;
+		const targetPos = isHorizontal ? Position.Left : Position.Top;
+		let wrapperWidth = 150;
+		let wrapperHeight = 60;
+		if (node.subgraph) {
+			const subgraphLayout = subgraphLayouts.get(node.subgraph);
+			const nodeLayout = subgraphLayout === null || subgraphLayout === void 0 ? void 0 : subgraphLayout.nodes.get(node.id);
+			if (nodeLayout) {
+				wrapperWidth = Math.max(20, Math.round(nodeLayout.width));
+				wrapperHeight = Math.max(20, Math.round(nodeLayout.height));
+			}
+		} else {
+			const size = calculateNodeSize(node.label, node.shape, !!imageUrl);
+			wrapperWidth = Math.max(20, Math.round(size.width));
+			wrapperHeight = Math.max(20, Math.round(size.height));
+		}
+		let data;
+		switch (portalType.toLowerCase()) {
+			case "image":
+				data = { src: imageUrl !== null && imageUrl !== void 0 ? imageUrl : "" };
+				break;
+			case "shape":
+				var _MERMAID_TO_PORTAL_SH;
+				data = {
+					shape: (_MERMAID_TO_PORTAL_SH = MERMAID_TO_PORTAL_SHAPE[node.shape]) !== null && _MERMAID_TO_PORTAL_SH !== void 0 ? _MERMAID_TO_PORTAL_SH : "rectangle",
+					componentFields: [generateComponentFieldNameInput(displayLabel)],
+					fill: colors.backgroundColor,
+					stroke: colors.borderColor,
+					strokeWidth: 2
+				};
+				break;
+			case "default":
+				data = {
+					name: displayLabel,
+					label: displayLabel,
+					description: "",
+					componentId: "file-note"
+				};
+				break;
+			case "builder":
+				data = {
+					componentName: "file-note",
+					componentFields: [
+						generateComponentFieldNameInput(displayLabel),
+						generateComponentFieldInput({
+							label: "Label",
+							data: displayLabel,
+							type: ComponentInputType.TextInput
+						}),
+						generateComponentFieldInput({
+							label: "Description",
+							data: "",
+							type: ComponentInputType.TextBox
+						})
+					]
+				};
+				break;
+			case "text":
+				data = { componentFields: [generateComponentFieldInput({
+					componentFieldId: "text",
+					label: "Text",
+					data: displayLabel,
+					type: ComponentInputType.TextBox
+				})] };
+				break;
+			case "code":
+				data = { componentFields: [generateComponentFieldNameInput(displayLabel), generateComponentFieldInput({
+					label: "Code",
+					data: "",
+					type: ComponentInputType.CodeEditor
+				})] };
+				break;
+			case "table":
+				data = {
+					componentFields: [generateComponentFieldNameInput(displayLabel)],
+					columns: [
+						"Task",
+						"Owner",
+						"Status",
+						"Due"
+					],
+					rows: [[
+						"Website revamp",
+						"Amara",
+						"In progress",
+						"May 12"
+					], [
+						"Marketing sync",
+						"Liu",
+						"Blocked",
+						"May 15"
+					]]
+				};
+				break;
+			case "cloud":
+				data = { componentFields: [generateComponentFieldNameInput(displayLabel)] };
+				break;
+			case "comment":
+				data = { componentFields: [generateComponentFieldNameInput(displayLabel)] };
+				break;
+			default: data = {
+				name: displayLabel,
+				label: displayLabel,
+				description: "",
+				componentId: "file-note"
+			};
+		}
+		reactFlowNodes.push({
+			id: node.id,
+			type: portalType,
+			position,
+			data,
+			style: {
+				width: wrapperWidth,
+				height: wrapperHeight
+			},
+			sourcePosition: sourcePos,
+			targetPosition: targetPos,
+			parentId: parentNode,
+			extent: parentNode ? "parent" : void 0,
+			draggable: true,
+			zIndex: 1
+		});
+	});
+	return {
+		nodes: reactFlowNodes,
+		edges: edges.map((edge, index) => {
+			const edgeColors = [
+				"#1976D2",
+				"#388E3C",
+				"#F57C00",
+				"#7B1FA2",
+				"#C2185B"
+			];
+			const edgeColor = edgeColors[index % edgeColors.length];
+			const edgeStyle = {
+				stroke: edgeColor,
+				strokeWidth: 2.5
+			};
+			const edgeType = "default";
+			const animated = true;
+			switch (edge.type) {
+				case "-->":
+				case "->": break;
+				case "---":
+					edgeStyle.strokeDasharray = "8,4";
+					break;
+				case "-.-":
+					edgeStyle.strokeDasharray = "4,4";
+					break;
+				case "==>":
+				case "===>":
+					edgeStyle.strokeWidth = 4;
+					break;
+			}
+			const sourceId = edge.isSourceSubgraph ? `subgraph-${edge.source}` : edge.source;
+			const targetId = edge.isTargetSubgraph ? `subgraph-${edge.target}` : edge.target;
+			return {
+				id: `edge-${edge.source}-${edge.target}-${index}`,
+				source: sourceId,
+				target: targetId,
+				label: edge.label,
+				type: edgeType,
+				animated,
+				style: edgeStyle,
+				labelStyle: {
+					fontSize: "12px",
+					fontWeight: "500",
+					color: edgeColor,
+					backgroundColor: "white",
+					padding: "2px 6px",
+					borderRadius: "4px",
+					border: `1px solid ${edgeColor}`
+				},
+				markerEnd: {
+					type: MarkerType.ArrowClosed,
+					width: 20,
+					height: 20,
+					color: edgeColor
+				},
+				sourceHandle: direction === "LR" || direction === "RL" ? "source-right" : "source-bottom",
+				targetHandle: direction === "LR" || direction === "RL" ? "target-left" : "target-top",
+				zIndex: 0
+			};
+		})
+	};
+}
+function layoutGraph(nodes, edges, subgraphs, direction) {
+	debugLog("Starting graph layout with direction:", direction);
+	debugLog(`Input: ${nodes.length} nodes, ${edges.length} edges, ${subgraphs.length} subgraphs`);
+	const subgraphLayouts = layoutSubgraphs(nodes, edges, subgraphs, direction);
+	const { subgraphPositions, standalonePositions } = layoutMetaGraph(nodes, edges, subgraphLayouts, direction);
+	adjustParentSizesAfterPositioning(subgraphLayouts, subgraphPositions, processSubgraphsInHierarchicalOrder(subgraphs), direction);
+	return createReactFlowElements(nodes, edges, subgraphs, subgraphLayouts, subgraphPositions, standalonePositions, direction);
+}
+function getParticipantX(index) {
+	const { COLUMN_WIDTH } = SEQUENCE_LAYOUT;
+	return index * COLUMN_WIDTH + COLUMN_WIDTH / 2;
+}
+function getRowY(rowIndex) {
+	const { HEADER_HEIGHT, ROW_HEIGHT } = SEQUENCE_LAYOUT;
+	return HEADER_HEIGHT + rowIndex * ROW_HEIGHT + ROW_HEIGHT / 2;
+}
+function rowHandleId(rowIndex, side, handleType) {
+	return `row-${rowIndex}-${side}-${handleType}`;
+}
+function convertSequenceDiagramToReactFlow(_x2) {
+	return _convertSequenceDiagramToReactFlow.apply(this, arguments);
+}
+function _convertSequenceDiagramToReactFlow() {
+	_convertSequenceDiagramToReactFlow = _asyncToGenerator(function* (mermaidCode) {
+		const { participants, messages } = parseSequenceDiagram(mermaidCode);
+		const { PARTICIPANT_NODE_WIDTH, MESSAGE_NODE_WIDTH, MESSAGE_NODE_HEIGHT, SELF_LOOP_OFFSET } = SEQUENCE_LAYOUT;
+		const hasSelfLoop = messages.some((m) => m.from === m.to);
+		const rowCount = messages.length + (hasSelfLoop ? 1 : 0);
+		const nodes = [];
+		const edges = [];
+		for (const p of participants) nodes.push({
+			id: `participant-${p.id}`,
+			type: "sequenceParticipant",
+			position: {
+				x: getParticipantX(p.index) - PARTICIPANT_NODE_WIDTH / 2,
+				y: 0
+			},
+			data: {
+				source: "mermaid",
+				label: p.name,
+				rowCount,
+				componentFields: [generateComponentFieldNameInput(p.name), generateComponentFieldInput({
+					componentFieldId: "color",
+					label: "Color",
+					data: "#000000",
+					type: ComponentInputType.ColorPicker
+				})]
+			}
+		});
+		for (const m of messages) {
+			const fromParticipant = participants.find((p) => p.id === m.from);
+			const toParticipant = participants.find((p) => p.id === m.to);
+			if (!fromParticipant || !toParticipant) continue;
+			const fromIndex = fromParticipant.index;
+			const toIndex = toParticipant.index;
+			const isSelf = fromIndex === toIndex;
+			const goesRight = fromIndex < toIndex;
+			const centerX = isSelf ? getParticipantX(fromIndex) + SELF_LOOP_OFFSET : (getParticipantX(fromIndex) + getParticipantX(toIndex)) / 2;
+			const messageId = `message-${m.rowIndex}`;
+			nodes.push({
+				id: messageId,
+				type: "shape",
+				position: {
+					x: centerX - MESSAGE_NODE_WIDTH / 2,
+					y: getRowY(m.rowIndex) - MESSAGE_NODE_HEIGHT / 2
+				},
+				data: {
+					source: "mermaid",
+					shape: "rectangle",
+					fill: "#f8fafc",
+					stroke: "#CCCCCC",
+					strokeWidth: 1,
+					componentFields: [generateComponentFieldNameInput(m.label)]
+				},
+				style: {
+					width: MESSAGE_NODE_WIDTH,
+					height: MESSAGE_NODE_HEIGHT
+				}
+			});
+			const edgeStyle = _objectSpread2({
+				stroke: "#94a3b8",
+				strokeWidth: 2
+			}, m.lineStyle === "dashed" ? { strokeDasharray: "4 4" } : {});
+			const markerEnd = m.arrowType !== "none" ? {
+				type: m.arrowType === "filled" ? MarkerType.ArrowClosed : MarkerType.Arrow,
+				width: 16,
+				height: 16,
+				color: "#94a3b8"
+			} : void 0;
+			const sourceSide = goesRight || isSelf ? "right" : "left";
+			const targetSide = isSelf ? "right" : goesRight ? "left" : "right";
+			edges.push({
+				id: `edge-${m.rowIndex}-a`,
+				source: `participant-${m.from}`,
+				target: messageId,
+				sourceHandle: rowHandleId(m.rowIndex, sourceSide, "source"),
+				targetHandle: isSelf ? "target-top" : sourceSide === "right" ? "target-left" : "target-right",
+				type: "smoothstep",
+				style: edgeStyle,
+				data: { source: "mermaid" }
+			});
+			edges.push(_objectSpread2(_objectSpread2({
+				id: `edge-${m.rowIndex}-b`,
+				source: messageId,
+				target: `participant-${m.to}`,
+				sourceHandle: isSelf ? "source-bottom" : goesRight ? "source-right" : "source-left",
+				targetHandle: rowHandleId(m.rowIndex + (isSelf ? 1 : 0), targetSide, "target"),
+				type: "smoothstep",
+				style: m.lineStyle === "dashed" ? edgeStyle : {
+					stroke: "#94a3b8",
+					strokeWidth: 2
+				}
+			}, markerEnd ? { markerEnd } : {}), {}, { data: { source: "mermaid" } }));
+		}
+		return {
+			nodes,
+			edges
+		};
+	});
+	return _convertSequenceDiagramToReactFlow.apply(this, arguments);
+}
+function convertFlowchartToReactFlow(_x3) {
+	return _convertFlowchartToReactFlow.apply(this, arguments);
+}
+function _convertFlowchartToReactFlow() {
+	_convertFlowchartToReactFlow = _asyncToGenerator(function* (mermaidCode) {
+		debugLog("Starting Mermaid to React Flow conversion");
+		debugLog("Mermaid code:", mermaidCode);
+		const { nodes, edges, subgraphs, direction } = parseMermaidCode(mermaidCode);
+		if (nodes.length === 0) {
+			debugLog("No nodes found in Mermaid diagram");
+			return {
+				nodes: [],
+				edges: []
+			};
+		}
+		debugLog(`Parsed ${nodes.length} nodes, ${edges.length} edges, ${subgraphs.length} subgraphs`);
+		const graphedResult = layoutGraph(nodes, edges, subgraphs, direction);
+		return {
+			nodes: graphedResult.nodes.map((node) => _objectSpread2(_objectSpread2({}, node), {}, { data: _objectSpread2(_objectSpread2({}, node.data), {}, { source: "mermaid" }) })),
+			edges: graphedResult.edges.map((edge) => _objectSpread2(_objectSpread2({}, edge), {}, { data: _objectSpread2(_objectSpread2({}, edge.data), {}, { source: "mermaid" }) }))
+		};
+	});
+	return _convertFlowchartToReactFlow.apply(this, arguments);
+}
+function convertMermaidToReactFlow(_x4) {
+	return _convertMermaidToReactFlow.apply(this, arguments);
+}
+function _convertMermaidToReactFlow() {
+	_convertMermaidToReactFlow = _asyncToGenerator(function* (mermaidCode) {
+		try {
+			if (detectDiagramType(mermaidCode) === "sequence") return convertSequenceDiagramToReactFlow(mermaidCode);
+			return convertFlowchartToReactFlow(mermaidCode);
+		} catch (error) {
+			console.error("Error converting Mermaid to React Flow:", error);
+			return {
+				nodes: [],
+				edges: []
+			};
+		}
+	});
+	return _convertMermaidToReactFlow.apply(this, arguments);
+}
+const BOUND_PADDING = 20;
+function createGroupNode(options) {
+	var _options$id, _options$name;
+	return {
+		id: (_options$id = options.id) !== null && _options$id !== void 0 ? _options$id : generateUUID$1(),
+		type: "group",
+		position: {
+			x: options.bounds.x,
+			y: options.bounds.y
+		},
+		data: {
+			childNodes: options.nodes,
+			componentFields: [generateComponentFieldNameInput((_options$name = options.name) !== null && _options$name !== void 0 ? _options$name : "Group")]
+		},
+		style: {
+			width: options.bounds.width + 20,
+			height: options.bounds.height + 50
+		}
+	};
+}
+function generateGroupNodeFromNodes(id, name, nodes) {
+	const bounds = nodes.map((node) => {
+		var _ref, _ref2, _node$height, _node$style, _node$measured, _ref3, _ref4, _node$width, _node$style2, _node$measured2;
+		return {
+			top: node.position.y,
+			left: node.position.x,
+			bottom: node.position.y + ((_ref = (_ref2 = (_node$height = node.height) !== null && _node$height !== void 0 ? _node$height : (_node$style = node.style) === null || _node$style === void 0 ? void 0 : _node$style.height) !== null && _ref2 !== void 0 ? _ref2 : (_node$measured = node.measured) === null || _node$measured === void 0 ? void 0 : _node$measured.height) !== null && _ref !== void 0 ? _ref : 0),
+			right: node.position.x + ((_ref3 = (_ref4 = (_node$width = node.width) !== null && _node$width !== void 0 ? _node$width : (_node$style2 = node.style) === null || _node$style2 === void 0 ? void 0 : _node$style2.width) !== null && _ref4 !== void 0 ? _ref4 : (_node$measured2 = node.measured) === null || _node$measured2 === void 0 ? void 0 : _node$measured2.width) !== null && _ref3 !== void 0 ? _ref3 : 0)
+		};
+	});
+	const minX = Math.min(...bounds.map((b) => b.left));
+	const minY = Math.min(...bounds.map((b) => b.top));
+	const maxX = Math.max(...bounds.map((b) => b.right));
+	const maxY = Math.max(...bounds.map((b) => b.bottom));
+	return createGroupNode({
+		id,
+		name,
+		nodes: nodes.map((node) => node.id),
+		bounds: {
+			x: minX - BOUND_PADDING,
+			y: minY - BOUND_PADDING,
+			width: maxX - minX + BOUND_PADDING * 2,
+			height: maxY - minY + BOUND_PADDING * 2
+		}
+	});
+}
+function resolveCloudIcon(_x, _x2) {
+	return _resolveCloudIcon.apply(this, arguments);
+}
+function _resolveCloudIcon() {
+	_resolveCloudIcon = _asyncToGenerator(function* (cloud, serviceName) {
+		const cloudName = cloud === null || cloud === void 0 ? void 0 : cloud.toLowerCase();
+		const icon = (cloudName === "azure" ? [...(yield import("./__azure-icons.DgR1F6C6.mjs")).default] : cloudName === "aws" ? [...(yield import("./__aws-icons.agWBtDk7.mjs")).default] : [...(yield import("./__aws-icons.agWBtDk7.mjs")).default, ...(yield import("./__azure-icons.DgR1F6C6.mjs")).default]).find((icon$1) => icon$1.name.toLowerCase() === serviceName.toLowerCase());
+		if (!icon) return null;
+		return `/${icon.cloud.toLowerCase()}-icons/${icon.relativePath}`;
+	});
+	return _resolveCloudIcon.apply(this, arguments);
+}
+function resolveAnimatedNode(_x3) {
+	return _resolveAnimatedNode.apply(this, arguments);
+}
+function _resolveAnimatedNode() {
+	_resolveAnimatedNode = _asyncToGenerator(function* (animatedIcon) {
+		const node = (yield import("./__animated-nodes.DI0XYTuw.mjs")).default.find((node$1) => node$1.name.toLowerCase() === animatedIcon.toLowerCase());
+		if (!node) return null;
+		return `/animated-nodes/${node.fileName}`;
+	});
+	return _resolveAnimatedNode.apply(this, arguments);
+}
+const EXPECTED_NODE_SIZE = {
+	databaseTableSQL: {
+		width: 500,
+		height: 400
+	},
+	table: {
+		width: 600,
+		height: 400
+	},
+	code: {
+		width: 300,
+		height: 400
+	}
+};
+const GROUP_BOUND_PADDING = 20;
+const GROUP_WIDTH_PADDING = 20;
+const GROUP_HEIGHT_PADDING = 50;
+const MIN_HORIZONTAL_GAP = 140;
+const ROW_ALIGNMENT_TOLERANCE = 80;
+function resolveDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getNodeSize(node) {
+	var _ref, _ref2, _ref3, _resolveDimension, _node$style, _node$measured, _ref4, _ref5, _ref6, _resolveDimension2, _node$style2, _node$measured2;
+	const expectedSize = node.type ? EXPECTED_NODE_SIZE[node.type] : void 0;
+	return {
+		width: (_ref = (_ref2 = (_ref3 = (_resolveDimension = resolveDimension(node.width)) !== null && _resolveDimension !== void 0 ? _resolveDimension : resolveDimension((_node$style = node.style) === null || _node$style === void 0 ? void 0 : _node$style.width)) !== null && _ref3 !== void 0 ? _ref3 : resolveDimension((_node$measured = node.measured) === null || _node$measured === void 0 ? void 0 : _node$measured.width)) !== null && _ref2 !== void 0 ? _ref2 : expectedSize === null || expectedSize === void 0 ? void 0 : expectedSize.width) !== null && _ref !== void 0 ? _ref : 0,
+		height: (_ref4 = (_ref5 = (_ref6 = (_resolveDimension2 = resolveDimension(node.height)) !== null && _resolveDimension2 !== void 0 ? _resolveDimension2 : resolveDimension((_node$style2 = node.style) === null || _node$style2 === void 0 ? void 0 : _node$style2.height)) !== null && _ref6 !== void 0 ? _ref6 : resolveDimension((_node$measured2 = node.measured) === null || _node$measured2 === void 0 ? void 0 : _node$measured2.height)) !== null && _ref5 !== void 0 ? _ref5 : expectedSize === null || expectedSize === void 0 ? void 0 : expectedSize.height) !== null && _ref4 !== void 0 ? _ref4 : 0
+	};
+}
+function resizeNodesLayouts(nodes) {
+	const resizeRules = nodes.map((node) => {
+		if (!node.type) return;
+		const expectedSize = EXPECTED_NODE_SIZE[node.type];
+		if (!expectedSize) return;
+		const size = getNodeSize(node);
+		return {
+			startX: node.position.x + expectedSize.width,
+			startY: node.position.y + expectedSize.height,
+			deltaX: Math.max(0, size.width - expectedSize.width),
+			deltaY: Math.max(0, size.height - expectedSize.height)
+		};
+	}).filter((rule) => Boolean(rule));
+	const resizedNodes = nodes.map((node) => {
+		var _node$data;
+		const childNodeIds = (_node$data = node.data) === null || _node$data === void 0 ? void 0 : _node$data.childNodes;
+		if (Array.isArray(childNodeIds)) return _objectSpread2({}, node);
+		const offsetX = resizeRules.reduce((total, rule) => {
+			if (!rule || rule.deltaX === 0 || node.position.x < rule.startX) return total;
+			return total + rule.deltaX;
+		}, 0);
+		const offsetY = resizeRules.reduce((total, rule) => {
+			if (!rule || rule.deltaY === 0 || node.position.y < rule.startY) return total;
+			return total + rule.deltaY;
+		}, 0);
+		if (offsetX === 0 && offsetY === 0) return node;
+		return _objectSpread2(_objectSpread2({}, node), {}, { position: {
+			x: node.position.x + offsetX,
+			y: node.position.y + offsetY
+		} });
+	});
+	const resizedNodesById = new Map(resizedNodes.map((node) => [node.id, node]));
+	const rowNodes = resizedNodes.filter((node) => {
+		var _node$data2;
+		return !Array.isArray((_node$data2 = node.data) === null || _node$data2 === void 0 ? void 0 : _node$data2.childNodes);
+	}).sort((a, b) => a.position.y === b.position.y ? a.position.x - b.position.x : a.position.y - b.position.y);
+	const rows = [];
+	for (const node of rowNodes) {
+		const row = rows.find((currentRow) => Math.abs(currentRow[0].position.y - node.position.y) <= ROW_ALIGNMENT_TOLERANCE);
+		if (row) {
+			row.push(node);
+			continue;
+		}
+		rows.push([node]);
+	}
+	for (const row of rows) {
+		row.sort((a, b) => a.position.x - b.position.x);
+		for (let index = 1; index < row.length; index += 1) {
+			const previousNode = row[index - 1];
+			const currentNode = row[index];
+			const previousNodeSize = getNodeSize(previousNode);
+			const minimumX = previousNode.position.x + previousNodeSize.width + MIN_HORIZONTAL_GAP;
+			if (currentNode.position.x >= minimumX) continue;
+			const shiftedNode = _objectSpread2(_objectSpread2({}, currentNode), {}, { position: {
+				x: minimumX,
+				y: currentNode.position.y
+			} });
+			row[index] = shiftedNode;
+			resizedNodesById.set(shiftedNode.id, shiftedNode);
+		}
+	}
+	return resizedNodes.map((node) => {
+		var _resizedNodesById$get, _node$data3;
+		const shiftedNode = (_resizedNodesById$get = resizedNodesById.get(node.id)) !== null && _resizedNodesById$get !== void 0 ? _resizedNodesById$get : node;
+		const childNodeIds = (_node$data3 = node.data) === null || _node$data3 === void 0 ? void 0 : _node$data3.childNodes;
+		if (!Array.isArray(childNodeIds)) return shiftedNode;
+		const childNodes = childNodeIds.map((childNodeId) => typeof childNodeId === "string" ? resizedNodesById.get(childNodeId) : void 0).filter((childNode) => Boolean(childNode));
+		if (childNodes.length === 0) return shiftedNode;
+		const bounds = childNodes.map((childNode) => {
+			const size = getNodeSize(childNode);
+			return {
+				left: childNode.position.x,
+				top: childNode.position.y,
+				right: childNode.position.x + size.width,
+				bottom: childNode.position.y + size.height
+			};
+		});
+		const minX = Math.min(...bounds.map((bound) => bound.left));
+		const minY = Math.min(...bounds.map((bound) => bound.top));
+		const maxX = Math.max(...bounds.map((bound) => bound.right));
+		const maxY = Math.max(...bounds.map((bound) => bound.bottom));
+		return _objectSpread2(_objectSpread2({}, shiftedNode), {}, {
+			position: {
+				x: minX - GROUP_BOUND_PADDING,
+				y: minY - GROUP_BOUND_PADDING
+			},
+			style: _objectSpread2(_objectSpread2({}, shiftedNode.style), {}, {
+				width: maxX - minX + GROUP_BOUND_PADDING * 2 + GROUP_WIDTH_PADDING,
+				height: maxY - minY + GROUP_BOUND_PADDING * 2 + GROUP_HEIGHT_PADDING
+			})
+		});
+	});
+}
+function hasValidPosition(position) {
+	if (!position) return false;
+	return Number.isFinite(position.x) && Number.isFinite(position.y);
+}
+function normalizeContextMarker(marker) {
+	if (!marker) return;
+	const markerType = marker.type.trim().toLowerCase();
+	let type;
+	if (markerType === "arrow") type = MarkerType.Arrow;
+	else if (markerType === "arrowclosed" || markerType === "arrow-closed" || markerType === "arrow_closed") type = MarkerType.ArrowClosed;
+	if (!type) return;
+	if (marker.color) return {
+		type,
+		color: marker.color
+	};
+	return { type };
+}
+function convertMermaidToReactFlowWithContext(_x3, _x4, _x5) {
+	return _convertMermaidToReactFlowWithContext.apply(this, arguments);
+}
+function _convertMermaidToReactFlowWithContext() {
+	_convertMermaidToReactFlowWithContext = _asyncToGenerator(function* (mermaidCode, context, options) {
+		var _context$groups;
+		const validatedContext = contextSchema.parse(context);
+		const reactFlowData = yield convertMermaidToReactFlow(mermaidCode);
+		const rfNodesPromises = reactFlowData.nodes.map(function() {
+			var _ref = _asyncToGenerator(function* (node) {
+				var _validatedContext$nod, _clonedNode$data$comp, _ctx$data, _clonedNode$data, _ctx$style, _ctx$style2, _ctx$style3, _ctx$style4;
+				const ctx = (_validatedContext$nod = validatedContext.nodes) === null || _validatedContext$nod === void 0 ? void 0 : _validatedContext$nod[node.id];
+				if (!ctx) return node;
+				const clonedNode = JSON.parse(JSON.stringify(node));
+				const componentFields = (_clonedNode$data$comp = clonedNode.data.componentFields) !== null && _clonedNode$data$comp !== void 0 ? _clonedNode$data$comp : [];
+				(_ctx$data = ctx.data) !== null && _ctx$data !== void 0 || (ctx.data = {});
+				(_clonedNode$data = clonedNode.data) !== null && _clonedNode$data !== void 0 || (clonedNode.data = {});
+				if (hasValidPosition(ctx.___position)) clonedNode.position = {
+					x: ctx.___position.x,
+					y: ctx.___position.y
+				};
+				if (ctx.type) {
+					clonedNode.type = ctx.type;
+					delete clonedNode.style;
+					if (ctx.type === "cloud") {
+						clonedNode.height = 150;
+						clonedNode.width = 150;
+						if (ctx.service) {
+							const cloudIcon = (options === null || options === void 0 ? void 0 : options.resolveCloudIcon) ? yield options.resolveCloudIcon(ctx.cloud, ctx.service) : yield resolveCloudIcon(ctx.cloud, ctx.service);
+							if (cloudIcon) clonedNode.data.iconSrc = cloudIcon;
+						}
+					}
+					if (ctx.type === "image" && ctx.src) clonedNode.data = _objectSpread2(_objectSpread2({}, clonedNode.data), {}, { src: ctx.src });
+					if (ctx.type === "gif") {
+						if (ctx.animatedIcon) {
+							const animatedNodeSrc = yield resolveAnimatedNode(ctx.animatedIcon);
+							if (animatedNodeSrc) clonedNode.data = _objectSpread2(_objectSpread2({}, clonedNode.data), {}, { src: animatedNodeSrc });
+						} else if (ctx.src) clonedNode.data = _objectSpread2(_objectSpread2({}, clonedNode.data), {}, { src: ctx.src });
+					}
+					if (ctx.type === "text" && ctx.value) {
+						const textComponentField = generateComponentFieldInput({
+							type: ComponentInputType.TextInput,
+							componentFieldId: "text",
+							label: "Text",
+							data: ctx.value,
+							isReadonly: true
+						});
+						componentFields.unshift(textComponentField);
+					}
+					if (ctx.type === "code" && ctx.value) {
+						const textComponentField = generateComponentFieldInput({
+							type: ComponentInputType.CodeEditor,
+							componentFieldId: "code",
+							label: "Code",
+							data: ctx.value,
+							isReadonly: true
+						});
+						componentFields.unshift(textComponentField);
+					}
+					if (ctx.type === "table" && ctx.table) {
+						var _ctx$table$rows, _ctx$table$columns;
+						clonedNode.data.title = ctx.name;
+						clonedNode.data.rows = (_ctx$table$rows = ctx.table.rows) !== null && _ctx$table$rows !== void 0 ? _ctx$table$rows : [];
+						clonedNode.data.columns = (_ctx$table$columns = ctx.table.columns) !== null && _ctx$table$columns !== void 0 ? _ctx$table$columns : [];
+					}
+					if (ctx.type === "data-source" || ctx.type === "db-table") {
+						ctx.type = "databaseTableSQL";
+						clonedNode.type = "databaseTableSQL";
+					}
+					if (ctx.type === "component") {
+						ctx.type = "builder";
+						clonedNode.type = "builder";
+						clonedNode.data.componentId = ctx.componentId;
+					}
+					if (ctx.type === "shape" && ctx.shape) {
+						clonedNode.data.shape = ctx.shape;
+						if (ctx.shape === "or" || ctx.shape === "summing-junction") {
+							var _clonedNode$width, _clonedNode$height;
+							const maxSize = Math.max((_clonedNode$width = clonedNode.width) !== null && _clonedNode$width !== void 0 ? _clonedNode$width : 0, (_clonedNode$height = clonedNode.height) !== null && _clonedNode$height !== void 0 ? _clonedNode$height : 0, 200);
+							clonedNode.width = maxSize;
+							clonedNode.height = maxSize;
+						}
+					}
+				}
+				if (ctx.name) ctx.data["Name"] = {
+					type: ComponentInputType.TextInput,
+					value: ctx.name
+				};
+				for (const key in ctx.data) {
+					const metaInput = ctx.data[key];
+					if (metaInput === void 0) continue;
+					const componentField = getComponentFieldByLabel(componentFields, key);
+					const newComponentField = generateComponentFieldInput({
+						label: key,
+						type: metaInput.type,
+						data: metaInput.value,
+						options: metaInput.options
+					});
+					if (!componentField) componentFields.push(newComponentField);
+					else {
+						componentField.type = newComponentField.type;
+						componentField.data = newComponentField.data;
+					}
+				}
+				if (ctx.dbConfig) clonedNode.data.serviceTable = {
+					serviceId: ctx.dbConfig.service,
+					serviceDbId: ctx.dbConfig.database,
+					tableName: ctx.dbConfig.tableName
+				};
+				if ((_ctx$style = ctx.style) === null || _ctx$style === void 0 ? void 0 : _ctx$style.height) clonedNode.height = ctx.style.height;
+				if ((_ctx$style2 = ctx.style) === null || _ctx$style2 === void 0 ? void 0 : _ctx$style2.width) clonedNode.width = ctx.style.width;
+				clonedNode.data = _objectSpread2(_objectSpread2(_objectSpread2({}, clonedNode.data), objectPick((_ctx$style3 = ctx.style) !== null && _ctx$style3 !== void 0 ? _ctx$style3 : {}, [
+					"fill",
+					"stroke",
+					"strokeWidth",
+					"strokeStyle",
+					"borderRadius",
+					"borderAnimationEnabled"
+				])), {}, {
+					componentFields,
+					strokeAnimation: ((_ctx$style4 = ctx.style) === null || _ctx$style4 === void 0 ? void 0 : _ctx$style4.borderAnimationEnabled) ? "dash" : void 0
+				}, ctx === null || ctx === void 0 ? void 0 : ctx.___internal);
+				return clonedNode;
+			});
+			return function(_x) {
+				return _ref.apply(this, arguments);
+			};
+		}());
+		const resolvedNodes = yield Promise.all(rfNodesPromises);
+		const groupNodes = Object.entries((_context$groups = context.groups) !== null && _context$groups !== void 0 ? _context$groups : {}).map(([nodeId, groupCtx]) => {
+			var _groupCtx$nodes, _groupCtx$name;
+			const childNodes = arrayNonNullable(((_groupCtx$nodes = groupCtx.nodes) !== null && _groupCtx$nodes !== void 0 ? _groupCtx$nodes : []).map((nodeId$1) => resolvedNodes.find((n) => n.id === nodeId$1)));
+			return generateGroupNodeFromNodes(nodeId, (_groupCtx$name = groupCtx.name) !== null && _groupCtx$name !== void 0 ? _groupCtx$name : "Group", childNodes);
+		});
+		const rfEdgesPromises = reactFlowData.edges.map(function() {
+			var _ref2 = _asyncToGenerator(function* (edge) {
+				var _validatedContext$edg, _ctx$type, _ctx$sourceHandle, _ctx$targetHandle, _normalizeContextMark, _normalizeContextMark2, _ctx$label, _ctx$style$borderAnim, _ctx$style5, _ctx$style$stroke, _ctx$style6, _edge$style, _ctx$style$strokeWidt, _ctx$style7, _edge$style2, _ctx$style8, _ctx$style9, _ctx$style10, _edge$style3;
+				const ctx = (_validatedContext$edg = validatedContext.edges) === null || _validatedContext$edg === void 0 ? void 0 : _validatedContext$edg[`${edge.source}-${edge.target}`];
+				if (!ctx) return edge;
+				return _objectSpread2(_objectSpread2({}, edge), {}, {
+					type: (_ctx$type = ctx.type) !== null && _ctx$type !== void 0 ? _ctx$type : edge.type,
+					sourceHandle: (_ctx$sourceHandle = ctx.sourceHandle) !== null && _ctx$sourceHandle !== void 0 ? _ctx$sourceHandle : edge.sourceHandle,
+					targetHandle: (_ctx$targetHandle = ctx.targetHandle) !== null && _ctx$targetHandle !== void 0 ? _ctx$targetHandle : edge.targetHandle,
+					markerStart: (_normalizeContextMark = normalizeContextMarker(ctx.markerStart)) !== null && _normalizeContextMark !== void 0 ? _normalizeContextMark : edge.markerStart,
+					markerEnd: (_normalizeContextMark2 = normalizeContextMarker(ctx.markerEnd)) !== null && _normalizeContextMark2 !== void 0 ? _normalizeContextMark2 : edge.markerEnd,
+					data: _objectSpread2(_objectSpread2({}, edge.data), ctx === null || ctx === void 0 ? void 0 : ctx.___internal),
+					label: (_ctx$label = ctx.label) !== null && _ctx$label !== void 0 ? _ctx$label : edge.label,
+					animated: (_ctx$style$borderAnim = (_ctx$style5 = ctx.style) === null || _ctx$style5 === void 0 ? void 0 : _ctx$style5.borderAnimationEnabled) !== null && _ctx$style$borderAnim !== void 0 ? _ctx$style$borderAnim : edge.animated,
+					style: _objectSpread2(_objectSpread2({}, edge.style), {}, {
+						stroke: (_ctx$style$stroke = (_ctx$style6 = ctx.style) === null || _ctx$style6 === void 0 ? void 0 : _ctx$style6.stroke) !== null && _ctx$style$stroke !== void 0 ? _ctx$style$stroke : (_edge$style = edge.style) === null || _edge$style === void 0 ? void 0 : _edge$style.stroke,
+						strokeWidth: (_ctx$style$strokeWidt = (_ctx$style7 = ctx.style) === null || _ctx$style7 === void 0 ? void 0 : _ctx$style7.strokeWidth) !== null && _ctx$style$strokeWidt !== void 0 ? _ctx$style$strokeWidt : (_edge$style2 = edge.style) === null || _edge$style2 === void 0 ? void 0 : _edge$style2.strokeWidth,
+						strokeDasharray: ((_ctx$style8 = ctx.style) === null || _ctx$style8 === void 0 ? void 0 : _ctx$style8.strokeStyle) === "dashed" ? "4 2" : ((_ctx$style9 = ctx.style) === null || _ctx$style9 === void 0 ? void 0 : _ctx$style9.strokeStyle) === "dotted" ? "1 2" : ((_ctx$style10 = ctx.style) === null || _ctx$style10 === void 0 ? void 0 : _ctx$style10.strokeStyle) === "solid" ? void 0 : (_edge$style3 = edge.style) === null || _edge$style3 === void 0 ? void 0 : _edge$style3.strokeDasharray
+					})
+				});
+			});
+			return function(_x2) {
+				return _ref2.apply(this, arguments);
+			};
+		}());
+		const resolvedEdges = yield Promise.all(rfEdgesPromises);
+		const combinedNodes = [...groupNodes, ...resolvedNodes.map((node) => {
+			const nodeParent = groupNodes.find((groupNode) => {
+				var _groupNode$data$child;
+				return (_groupNode$data$child = groupNode.data.childNodes) === null || _groupNode$data$child === void 0 ? void 0 : _groupNode$data$child.includes(node.id);
+			});
+			if (nodeParent) return _objectSpread2(_objectSpread2({}, node), {}, { parentId: nodeParent.id });
+			return node;
+		})];
+		return {
+			edges: resolvedEdges,
+			nodes: (options === null || options === void 0 ? void 0 : options.repositionNodes) ? resizeNodesLayouts(combinedNodes) : combinedNodes
+		};
+	});
+	return _convertMermaidToReactFlowWithContext.apply(this, arguments);
+}
+const CONTEXT_SHAPES = new Set([
+	"rectangle",
+	"rounded-rect",
+	"ellipse",
+	"diamond",
+	"triangle",
+	"parallelogram",
+	"trapezoid",
+	"hexagon",
+	"document",
+	"cylinder",
+	"delay",
+	"off-page-connector",
+	"display",
+	"collate",
+	"sort",
+	"terminator",
+	"or",
+	"database",
+	"multiple-documents",
+	"subroutine",
+	"manual-input",
+	"summing-junction",
+	"internal-storage"
+]);
+const COMPONENT_INPUT_TYPES = new Set(Object.values(ComponentInputType));
+const INLINE_MERMAID_LABEL_MAX_LENGTH = 32;
+const KNOWN_NODE_DATA_KEYS = new Set([
+	"componentFields",
+	"shape",
+	"fill",
+	"stroke",
+	"strokeWidth",
+	"strokeStyle",
+	"borderRadius",
+	"borderAnimationEnabled",
+	"strokeAnimation",
+	"src",
+	"animatedIcon",
+	"iconSrc",
+	"componentId",
+	"serviceTable",
+	"title",
+	"columns",
+	"rows",
+	"name",
+	"label",
+	"value",
+	"cloud",
+	"service",
+	"childNodes"
+]);
+function isComponentInputType(value) {
+	return COMPONENT_INPUT_TYPES.has(value);
+}
+function toRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function pickString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	return trimmed;
+}
+function pickPosition(value) {
+	const position = toRecord(value);
+	if (!position) return;
+	if (typeof position.x !== "number" || !Number.isFinite(position.x)) return;
+	if (typeof position.y !== "number" || !Number.isFinite(position.y)) return;
+	return {
+		x: position.x,
+		y: position.y
+	};
+}
+function getFieldValue(fieldData) {
+	if (!Array.isArray(fieldData) || fieldData.length !== 1) return fieldData;
+	const first = toRecord(fieldData[0]);
+	if (!first) return fieldData;
+	if (!("value" in first)) return fieldData;
+	return first.value;
+}
+function getFieldByLabel(fields, label) {
+	return fields.find((field) => {
+		var _pickString;
+		return ((_pickString = pickString(field.label)) === null || _pickString === void 0 ? void 0 : _pickString.toLowerCase()) === label.toLowerCase() && pickString(field.type);
+	});
+}
+function getFieldString(fields, label) {
+	const field = getFieldByLabel(fields, label);
+	if (!field) return;
+	return pickString(getFieldValue(field.data));
+}
+function isEmptyFieldValue(value) {
+	if (typeof value === "string") return value.trim().length === 0;
+	return value === void 0 || value === null;
+}
+function parseStrokeStyle(dashArray) {
+	if (typeof dashArray !== "string" || !dashArray.trim()) return;
+	const normalized = dashArray.replaceAll(",", " ").replace(/\s+/g, " ").trim();
+	if (normalized === "1 2") return "dotted";
+	if (normalized === "4 2" || normalized === "4 4" || normalized === "8 4") return "dashed";
+	return "solid";
+}
+function normalizeMarker(marker) {
+	if (typeof marker === "string") return { type: marker };
+	const markerRecord = toRecord(marker);
+	if (!markerRecord) return;
+	const type = pickString(markerRecord.type);
+	if (!type) return;
+	const color = pickString(markerRecord.color);
+	if (color) return {
+		type,
+		color
+	};
+	return { type };
+}
+function escapeMermaidText(value) {
+	return value.replaceAll("\"", "\\\"");
+}
+function canInlineMermaidLabel(value) {
+	if (value.length > INLINE_MERMAID_LABEL_MAX_LENGTH) return false;
+	if (value.includes("\n") || value.includes("\r")) return false;
+	return true;
+}
+function normalizeDetailedMermaidLabel(value) {
+	return value.split(/\r?\n/).map((line) => line.replace(/\s+/g, " ").trim()).filter((line) => line.length > 0).join("\n");
+}
+function toComponentFields(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((field) => toRecord(field)).filter((field) => field !== void 0);
+}
+function buildContextEdges(edges, nodeIdMap) {
+	const contextEdges = {};
+	for (const edge of edges) {
+		var _toRecord, _toRecord2;
+		const source = nodeIdMap.get(edge.source);
+		const target = nodeIdMap.get(edge.target);
+		if (!source || !target) continue;
+		const edgeContext = {};
+		const edgeType = pickString(edge.type);
+		if (edgeType) edgeContext.type = edgeType;
+		const sourceHandle = pickString(edge.sourceHandle);
+		if (sourceHandle) edgeContext.sourceHandle = sourceHandle;
+		const targetHandle = pickString(edge.targetHandle);
+		if (targetHandle) edgeContext.targetHandle = targetHandle;
+		const edgeLabel = pickString(edge.label);
+		if (edgeLabel) edgeContext.label = edgeLabel;
+		const edgeStyleRecord = (_toRecord = toRecord(edge.style)) !== null && _toRecord !== void 0 ? _toRecord : {};
+		const edgeStyle = {};
+		const stroke = pickString(edgeStyleRecord.stroke);
+		if (stroke) edgeStyle.stroke = stroke;
+		if (typeof edgeStyleRecord.strokeWidth === "number") edgeStyle.strokeWidth = edgeStyleRecord.strokeWidth;
+		const strokeStyle = parseStrokeStyle(edgeStyleRecord.strokeDasharray);
+		if (strokeStyle) edgeStyle.strokeStyle = strokeStyle;
+		if (typeof edge.animated === "boolean") edgeStyle.borderAnimationEnabled = edge.animated;
+		if (Object.keys(edgeStyle).length > 0) edgeContext.style = edgeStyle;
+		const markerStart = normalizeMarker(edge.markerStart);
+		if (markerStart) edgeContext.markerStart = markerStart;
+		const markerEnd = normalizeMarker(edge.markerEnd);
+		if (markerEnd) edgeContext.markerEnd = markerEnd;
+		const edgeData = (_toRecord2 = toRecord(edge.data)) !== null && _toRecord2 !== void 0 ? _toRecord2 : {};
+		if (Object.keys(edgeData).length > 0) edgeContext.___internal = edgeData;
+		if (Object.keys(edgeContext).length > 0) contextEdges[`${source}-${target}`] = edgeContext;
+	}
+	return contextEdges;
+}
+function buildContextGroups(groupNodes, nodeIdMap) {
+	const contextGroups = {};
+	for (const groupNode of groupNodes) {
+		var _toRecord;
+		const groupData = (_toRecord = toRecord(groupNode.data)) !== null && _toRecord !== void 0 ? _toRecord : {};
+		const childNodes = Array.isArray(groupData.childNodes) ? groupData.childNodes.map((childId) => typeof childId === "string" ? nodeIdMap.get(childId) : void 0).filter((childId) => childId !== void 0) : [];
+		const name = getFieldString(Array.isArray(groupData.componentFields) ? groupData.componentFields.map((field) => toRecord(field)).filter((field) => field !== void 0) : [], "Name");
+		if (!name && childNodes.length === 0) continue;
+		contextGroups[groupNode.id] = {
+			name: name !== null && name !== void 0 ? name : void 0,
+			nodes: childNodes
+		};
+	}
+	return contextGroups;
+}
+function buildContextNodes(graphNodes, nodeIdMap) {
+	const contextNodes = {};
+	for (const node of graphNodes) {
+		var _toRecord, _toRecord2, _pickString, _pickString2;
+		const mappedNodeId = nodeIdMap.get(node.id);
+		if (!mappedNodeId) continue;
+		const nodeData = (_toRecord = toRecord(node.data)) !== null && _toRecord !== void 0 ? _toRecord : {};
+		const nodeStyle = (_toRecord2 = toRecord(node.style)) !== null && _toRecord2 !== void 0 ? _toRecord2 : {};
+		const componentFields = Array.isArray(nodeData.componentFields) ? nodeData.componentFields.map((field) => toRecord(field)).filter((field) => field !== void 0) : [];
+		const nodeContext = {};
+		const nodeType = pickString(node.type);
+		if (nodeType) nodeContext.type = nodeType;
+		const nameField = getFieldByLabel(componentFields, "Name");
+		const nameRawValue = nameField ? getFieldValue(nameField.data) : void 0;
+		const name = pickString(nameRawValue);
+		if (name) nodeContext.name = name;
+		const textField = nodeType === "text" ? getFieldByLabel(componentFields, "Text") : void 0;
+		const textRawValue = textField ? getFieldValue(textField.data) : void 0;
+		const textValue = pickString(textRawValue);
+		if (nodeType === "text") {
+			if (textValue) nodeContext.value = textValue;
+		}
+		const codeField = nodeType === "code" ? getFieldByLabel(componentFields, "Code") : void 0;
+		const codeRawValue = codeField ? getFieldValue(codeField.data) : void 0;
+		const codeValue = pickString(codeRawValue);
+		if (nodeType === "code") {
+			if (codeValue) nodeContext.value = codeValue;
+		}
+		const src = pickString(nodeData.src);
+		if (src) nodeContext.src = src;
+		const animatedIcon = pickString(nodeData.animatedIcon);
+		if (animatedIcon) nodeContext.animatedIcon = animatedIcon;
+		const cloud = pickString(nodeData.cloud);
+		if (cloud) nodeContext.cloud = cloud;
+		const service = pickString(nodeData.service);
+		if (service) nodeContext.service = service;
+		const componentId = pickString(nodeData.componentId);
+		if (componentId) nodeContext.componentId = componentId;
+		const shape = pickString(nodeData.shape);
+		if (shape && CONTEXT_SHAPES.has(shape)) nodeContext.shape = shape;
+		const style = {};
+		const width = typeof node.width === "number" ? node.width : typeof nodeStyle.width === "number" ? nodeStyle.width : void 0;
+		if (typeof width === "number") style.width = width;
+		const height = typeof node.height === "number" ? node.height : typeof nodeStyle.height === "number" ? nodeStyle.height : void 0;
+		if (typeof height === "number") style.height = height;
+		const fill = (_pickString = pickString(nodeData.fill)) !== null && _pickString !== void 0 ? _pickString : pickString(nodeStyle.fill);
+		if (fill) style.fill = fill;
+		const stroke = (_pickString2 = pickString(nodeData.stroke)) !== null && _pickString2 !== void 0 ? _pickString2 : pickString(nodeStyle.stroke);
+		if (stroke) style.stroke = stroke;
+		const strokeWidth = typeof nodeData.strokeWidth === "number" ? nodeData.strokeWidth : typeof nodeStyle.strokeWidth === "number" ? nodeStyle.strokeWidth : void 0;
+		if (typeof strokeWidth === "number") style.strokeWidth = strokeWidth;
+		const borderRadius = typeof nodeData.borderRadius === "number" ? nodeData.borderRadius : typeof nodeStyle.borderRadius === "number" ? nodeStyle.borderRadius : void 0;
+		if (typeof borderRadius === "number") style.borderRadius = borderRadius;
+		const strokeStyleFromData = pickString(nodeData.strokeStyle);
+		if (strokeStyleFromData === "solid" || strokeStyleFromData === "dashed" || strokeStyleFromData === "dotted") style.strokeStyle = strokeStyleFromData;
+		else {
+			const strokeStyleFromDash = parseStrokeStyle(nodeStyle.strokeDasharray);
+			if (strokeStyleFromDash) style.strokeStyle = strokeStyleFromDash;
+		}
+		const borderAnimationEnabled = typeof nodeData.borderAnimationEnabled === "boolean" ? nodeData.borderAnimationEnabled : nodeData.strokeAnimation === "dash" ? true : void 0;
+		if (typeof borderAnimationEnabled === "boolean") style.borderAnimationEnabled = borderAnimationEnabled;
+		if (Object.keys(style).length > 0) nodeContext.style = style;
+		const tableColumns = Array.isArray(nodeData.columns) ? nodeData.columns.filter((value) => typeof value === "string") : void 0;
+		const tableRows = Array.isArray(nodeData.rows) ? nodeData.rows.map((row) => Array.isArray(row) ? row.filter((value) => typeof value === "string") : void 0).filter((row) => row !== void 0) : void 0;
+		if (tableColumns || tableRows) nodeContext.table = {
+			columns: tableColumns !== null && tableColumns !== void 0 ? tableColumns : [],
+			rows: tableRows !== null && tableRows !== void 0 ? tableRows : []
+		};
+		const serviceTable = toRecord(nodeData.serviceTable);
+		const serviceId = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.serviceId);
+		const serviceDbId = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.serviceDbId);
+		const tableName = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.tableName);
+		if (serviceId && serviceDbId && tableName) nodeContext.dbConfig = {
+			service: serviceId,
+			database: serviceDbId,
+			tableName
+		};
+		const dynamicData = {};
+		for (const field of componentFields) {
+			const label$1 = pickString(field.label);
+			const type = pickString(field.type);
+			if (!label$1 || !type || !isComponentInputType(type)) continue;
+			const componentType = type;
+			const normalizedLabel = label$1.toLowerCase();
+			if (normalizedLabel === "name") continue;
+			if (nodeType === "text" && normalizedLabel === "text") continue;
+			if (nodeType === "code" && normalizedLabel === "code") continue;
+			const options = Array.isArray(field.options) ? field.options.filter((option) => typeof option === "string") : void 0;
+			dynamicData[label$1] = {
+				type: componentType,
+				value: getFieldValue(field.data),
+				options: options && options.length > 0 ? options : void 0
+			};
+		}
+		if (nameField && !name && isEmptyFieldValue(nameRawValue)) {
+			const nameType = pickString(nameField.type);
+			if (nameType && isComponentInputType(nameType)) {
+				const nameOptions = Array.isArray(nameField.options) ? nameField.options.filter((option) => typeof option === "string") : void 0;
+				dynamicData.Name = {
+					type: nameType,
+					value: "",
+					options: nameOptions && nameOptions.length > 0 ? nameOptions : void 0
+				};
+			}
+		}
+		if (textField && !textValue && isEmptyFieldValue(textRawValue)) {
+			const textType = pickString(textField.type);
+			if (textType && isComponentInputType(textType)) {
+				const textOptions = Array.isArray(textField.options) ? textField.options.filter((option) => typeof option === "string") : void 0;
+				dynamicData.Text = {
+					type: textType,
+					value: "",
+					options: textOptions && textOptions.length > 0 ? textOptions : void 0
+				};
+			}
+		}
+		if (codeField && !codeValue && isEmptyFieldValue(codeRawValue)) {
+			const codeType = pickString(codeField.type);
+			if (codeType && isComponentInputType(codeType)) {
+				const codeOptions = Array.isArray(codeField.options) ? codeField.options.filter((option) => typeof option === "string") : void 0;
+				dynamicData.Code = {
+					type: codeType,
+					value: "",
+					options: codeOptions && codeOptions.length > 0 ? codeOptions : void 0
+				};
+			}
+		}
+		if (Object.keys(dynamicData).length > 0) nodeContext.data = dynamicData;
+		const position = pickPosition(node.position);
+		if (position) nodeContext.___position = position;
+		const internalData = Object.entries(nodeData).reduce((acc, [key, value]) => {
+			if (KNOWN_NODE_DATA_KEYS.has(key)) return acc;
+			acc[key] = value;
+			return acc;
+		}, {});
+		if (nodeType === "builder" && Array.isArray(nodeData.componentFields)) internalData.componentFields = nodeData.componentFields;
+		const iconSrc = pickString(nodeData.iconSrc);
+		if (iconSrc) internalData.iconSrc = iconSrc;
+		const label = pickString(nodeData.label);
+		if (label) internalData.label = label;
+		const internalCloud = pickString(nodeData.cloud);
+		if (internalCloud) internalData.cloud = internalCloud;
+		if (Object.keys(internalData).length > 0) nodeContext.___internal = internalData;
+		if (Object.keys(nodeContext).length > 0) contextNodes[mappedNodeId] = nodeContext;
+	}
+	return contextNodes;
+}
+function buildValidatedContext(graphNodes, edges, groupNodes, nodeIdMap) {
+	const contextNodes = buildContextNodes(graphNodes, nodeIdMap);
+	const contextEdges = buildContextEdges(edges, nodeIdMap);
+	const contextGroups = buildContextGroups(groupNodes, nodeIdMap);
+	const context = {};
+	if (Object.keys(contextNodes).length > 0) context.nodes = contextNodes;
+	if (Object.keys(contextEdges).length > 0) context.edges = contextEdges;
+	if (Object.keys(contextGroups).length > 0) context.groups = contextGroups;
+	return contextSchema.parse(context);
+}
+function inferDirection(nodes, edges) {
+	const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+	let horizontalWeight = 0;
+	let verticalWeight = 0;
+	let weightedEdges = 0;
+	for (const edge of edges) {
+		const sourceNode = nodeMap.get(edge.source);
+		const targetNode = nodeMap.get(edge.target);
+		if (!sourceNode || !targetNode) continue;
+		horizontalWeight += Math.abs(targetNode.position.x - sourceNode.position.x);
+		verticalWeight += Math.abs(targetNode.position.y - sourceNode.position.y);
+		weightedEdges += 1;
+	}
+	if (weightedEdges > 0) return horizontalWeight >= verticalWeight ? "LR" : "TB";
+	const xs = nodes.map((node) => node.position.x);
+	const ys = nodes.map((node) => node.position.y);
+	return Math.max(...xs, 0) - Math.min(...xs, 0) >= Math.max(...ys, 0) - Math.min(...ys, 0) ? "LR" : "TB";
+}
+function isAlreadyNormalizedId(sourceId) {
+	return /^[A-Za-z]+$/.test(sourceId);
+}
+function indexToAlphabetId(index) {
+	let current = index;
+	let result = "";
+	while (current >= 0) {
+		result = String.fromCharCode(current % 26 + 65) + result;
+		current = Math.floor(current / 26) - 1;
+	}
+	return result;
+}
+function buildNodeIdMap(graphNodes) {
+	const usedMermaidIds = /* @__PURE__ */ new Set();
+	const nodeIdMap = /* @__PURE__ */ new Map();
+	let alphabeticIndex = 0;
+	graphNodes.forEach((node) => {
+		if (isAlreadyNormalizedId(node.id) && !usedMermaidIds.has(node.id)) {
+			nodeIdMap.set(node.id, node.id);
+			usedMermaidIds.add(node.id);
+			return;
+		}
+		let mappedNodeId = indexToAlphabetId(alphabeticIndex);
+		alphabeticIndex += 1;
+		while (usedMermaidIds.has(mappedNodeId)) {
+			mappedNodeId = indexToAlphabetId(alphabeticIndex);
+			alphabeticIndex += 1;
+		}
+		nodeIdMap.set(node.id, mappedNodeId);
+		usedMermaidIds.add(mappedNodeId);
+	});
+	return nodeIdMap;
+}
+function resolveMermaidNodeLabel(node) {
+	const nodeType = node.type;
+	const nodeData = toRecord(node.data);
+	const componentFields = Array.isArray(nodeData === null || nodeData === void 0 ? void 0 : nodeData.componentFields) ? nodeData.componentFields.map((field) => toRecord(field)).filter((field) => field !== void 0) : [];
+	const name = getFieldString(componentFields, "Name");
+	if (nodeType === "text") return getFieldString(componentFields, "Text");
+	if (nodeType === "code") return getFieldString(componentFields, "Code");
+	if (nodeType === "shape") return name;
+	if (nodeType === "cloud") return name;
+	if (nodeType === "table") return name;
+	if (nodeType === "gif") return name;
+}
+function formatInlineRichTextSegment(text, attributes) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	let output = trimmed;
+	const link = pickString(attributes === null || attributes === void 0 ? void 0 : attributes.link);
+	if ((attributes === null || attributes === void 0 ? void 0 : attributes.code) === true) output = `\`${output}\``;
+	if ((attributes === null || attributes === void 0 ? void 0 : attributes.bold) === true) output = `**${output}**`;
+	if (link) output = `[${output}](${link})`;
+	return output;
+}
+function collectQuillOps(value) {
+	const ops = [];
+	function visit(input) {
+		if (!input) return;
+		if (Array.isArray(input)) {
+			for (const item of input) visit(item);
+			return;
+		}
+		const record = toRecord(input);
+		if (!record) return;
+		if (Array.isArray(record.ops)) {
+			visit(record.ops);
+			return;
+		}
+		if ("insert" in record) {
+			ops.push(record);
+			return;
+		}
+		if ("value" in record) visit(record.value);
+	}
+	visit(value);
+	return ops;
+}
+function formatQuillRichTextAsMarkdown(value) {
+	const ops = collectQuillOps(value);
+	if (ops.length === 0) return;
+	const lines = [];
+	let currentLine = "";
+	for (const op of ops) {
+		const insert = op.insert;
+		if (typeof insert !== "string") continue;
+		const attributes = toRecord(op.attributes);
+		const parts = insert.split("\n");
+		for (let index = 0; index < parts.length; index += 1) {
+			const part = parts[index];
+			if (part) {
+				const formattedPart = formatInlineRichTextSegment(part, attributes);
+				if (formattedPart) {
+					if (currentLine) currentLine += " ";
+					currentLine += formattedPart;
+				}
+			}
+			if (!(index < parts.length - 1)) continue;
+			const normalizedLine = currentLine.replace(/\s+/g, " ").trim();
+			if (normalizedLine) if ((attributes === null || attributes === void 0 ? void 0 : attributes.list) === "bullet" || (attributes === null || attributes === void 0 ? void 0 : attributes.list) === "ordered") lines.push(`- ${normalizedLine}`);
+			else lines.push(normalizedLine);
+			currentLine = "";
+		}
+	}
+	const trailingLine = currentLine.replace(/\s+/g, " ").trim();
+	if (trailingLine) lines.push(trailingLine);
+	if (lines.length === 0) return;
+	return lines.join("\n");
+}
+function formatDetailValue(value) {
+	if (typeof value === "string") {
+		const normalized = value.replace(/\s+/g, " ").trim();
+		if (!normalized) return;
+		return normalized;
+	}
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		const formatted = value.map((item) => formatDetailValue(item)).filter((item) => item !== void 0);
+		if (formatted.length === 0) return;
+		return formatted.join(",");
+	}
+	const valueRecord = toRecord(value);
+	if (valueRecord) {
+		const entries = Object.entries(valueRecord).slice(0, 2).map(([key, item]) => {
+			const formatted = formatDetailValue(item);
+			if (!formatted) return;
+			return `${key}:${formatted}`;
+		}).filter((entry) => entry !== void 0);
+		if (entries.length === 0) return;
+		return entries.join(",");
+	}
+}
+function getNodeName(nodeData, componentFields) {
+	var _getFieldString;
+	return (_getFieldString = getFieldString(componentFields, "Name")) !== null && _getFieldString !== void 0 ? _getFieldString : pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.name);
+}
+function buildFieldLines(componentFields, excludedLabels) {
+	const lines = [];
+	for (const field of componentFields) {
+		const label = pickString(field.label);
+		const type = pickString(field.type);
+		if (!label || !type || !isComponentInputType(type)) continue;
+		if (excludedLabels.has(label.toLowerCase())) continue;
+		const rawValue = getFieldValue(field.data);
+		const value = type === ComponentInputType.RichTextEditor ? formatQuillRichTextAsMarkdown(rawValue) : formatDetailValue(rawValue);
+		const options = Array.isArray(field.options) ? field.options.filter((option) => typeof option === "string") : [];
+		if (!value && options.length === 0) continue;
+		if (value && options.length > 0) {
+			lines.push(`${label}: ${value} [${options.join("/")}]`);
+			continue;
+		}
+		if (value) {
+			lines.push(`${label}: ${value}`);
+			continue;
+		}
+		lines.push(`${label}: [${options.join("/")}]`);
+	}
+	return lines;
+}
+function buildDetailedLabel(lines) {
+	const compact = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+	if (compact.length === 0) return;
+	return compact.join("\n");
+}
+function resolveMermaidDetailedNodeLabel(node) {
+	const nodeType = pickString(node.type);
+	const nodeData = toRecord(node.data);
+	const componentFields = toComponentFields(nodeData === null || nodeData === void 0 ? void 0 : nodeData.componentFields);
+	const name = getNodeName(nodeData, componentFields);
+	if (nodeType === "text") {
+		var _getFieldString2;
+		const text = (_getFieldString2 = getFieldString(componentFields, "Text")) !== null && _getFieldString2 !== void 0 ? _getFieldString2 : pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.value);
+		return buildDetailedLabel([text ? `Text: ${text}` : "Text", ...buildFieldLines(componentFields, new Set(["name", "text"]))]);
+	}
+	if (nodeType === "code") {
+		var _getFieldString3, _code$split$;
+		const code = (_getFieldString3 = getFieldString(componentFields, "Code")) !== null && _getFieldString3 !== void 0 ? _getFieldString3 : pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.value);
+		const firstLine = code === null || code === void 0 || (_code$split$ = code.split(/\r?\n/)[0]) === null || _code$split$ === void 0 ? void 0 : _code$split$.trim();
+		return buildDetailedLabel([firstLine ? `Code: ${firstLine}` : "Code", ...buildFieldLines(componentFields, new Set(["name", "code"]))]);
+	}
+	if (nodeType === "data-source" || nodeType === "databaseTableSQL") {
+		var _pickString, _pickString2, _pickString3;
+		const lines = [];
+		const serviceTable = toRecord(nodeData === null || nodeData === void 0 ? void 0 : nodeData.serviceTable);
+		const dbConfig = toRecord(nodeData === null || nodeData === void 0 ? void 0 : nodeData.dbConfig);
+		const database = (_pickString = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.serviceDbId)) !== null && _pickString !== void 0 ? _pickString : pickString(dbConfig === null || dbConfig === void 0 ? void 0 : dbConfig.database);
+		const tableName = (_pickString2 = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.tableName)) !== null && _pickString2 !== void 0 ? _pickString2 : pickString(dbConfig === null || dbConfig === void 0 ? void 0 : dbConfig.tableName);
+		const dbService = (_pickString3 = pickString(serviceTable === null || serviceTable === void 0 ? void 0 : serviceTable.serviceId)) !== null && _pickString3 !== void 0 ? _pickString3 : pickString(dbConfig === null || dbConfig === void 0 ? void 0 : dbConfig.service);
+		const dataSourceName = name !== null && name !== void 0 ? name : tableName;
+		lines.push(dataSourceName ? `DataSource: ${dataSourceName}` : "DataSource");
+		if (database && tableName) lines.push(`db: ${database}.${tableName}`);
+		if (dbService) lines.push(`service: ${dbService}`);
+		lines.push(...buildFieldLines(componentFields, new Set(["name"])));
+		return buildDetailedLabel(lines);
+	}
+	if (nodeType === "cloud") {
+		const lines = [];
+		lines.push(name ? `Cloud: ${name}` : "Cloud");
+		const cloud = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.cloud);
+		if (cloud) lines.push(`provider: ${cloud}`);
+		const service = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.service);
+		if (service) lines.push(`service: ${service}`);
+		lines.push(...buildFieldLines(componentFields, new Set(["name"])));
+		return buildDetailedLabel(lines);
+	}
+	if (nodeType === "table" || nodeType === "dataTableInterface") {
+		var _pickString4;
+		const lines = [];
+		const table = toRecord(nodeData === null || nodeData === void 0 ? void 0 : nodeData.table);
+		const tableName = (_pickString4 = pickString(table === null || table === void 0 ? void 0 : table.name)) !== null && _pickString4 !== void 0 ? _pickString4 : name;
+		lines.push(tableName ? `Table: ${tableName}` : "Table");
+		const columns = Array.isArray(nodeData === null || nodeData === void 0 ? void 0 : nodeData.columns) ? nodeData.columns.filter((value) => typeof value === "string").length : Array.isArray(table === null || table === void 0 ? void 0 : table.columns) ? table.columns.length : 0;
+		const rows = Array.isArray(nodeData === null || nodeData === void 0 ? void 0 : nodeData.rows) ? nodeData.rows.filter((value) => Array.isArray(value)).length : Array.isArray(table === null || table === void 0 ? void 0 : table.rows) ? table.rows.length : 0;
+		lines.push(`columns: ${columns}`);
+		lines.push(`rows: ${rows}`);
+		lines.push(...buildFieldLines(componentFields, new Set(["name"])));
+		return buildDetailedLabel(lines);
+	}
+	if (nodeType === "shape") {
+		const fieldLines = buildFieldLines(componentFields, /* @__PURE__ */ new Set());
+		if (fieldLines.length > 0) return buildDetailedLabel(fieldLines);
+		if (name) return `Name: ${name}`;
+		return;
+	}
+	if (nodeType === "gif") {
+		const src = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.src);
+		return buildDetailedLabel([
+			name ? `Gif: ${name}` : src ? `Gif: ${src}` : "Gif",
+			...src ? [`src: ${src}`] : [],
+			...buildFieldLines(componentFields, new Set(["name"]))
+		]);
+	}
+	if (nodeType === "image") {
+		const src = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.src);
+		return buildDetailedLabel([
+			name ? `Image: ${name}` : src ? `Image: ${src}` : "Image",
+			...src ? [`src: ${src}`] : [],
+			...buildFieldLines(componentFields, new Set(["name"]))
+		]);
+	}
+	if (nodeType === "group") {
+		const childCount = Array.isArray(nodeData === null || nodeData === void 0 ? void 0 : nodeData.childNodes) ? nodeData.childNodes.length : 0;
+		return buildDetailedLabel([
+			name ? `Group: ${name}` : "Group",
+			`children: ${childCount}`,
+			...buildFieldLines(componentFields, new Set(["name"]))
+		]);
+	}
+	if (nodeType === "sequenceParticipant") {
+		var _getFieldString4, _getFieldString5;
+		const label = (_getFieldString4 = getFieldString(componentFields, "Label")) !== null && _getFieldString4 !== void 0 ? _getFieldString4 : pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.label);
+		const participantName = name !== null && name !== void 0 ? name : label;
+		const rowCount = typeof (nodeData === null || nodeData === void 0 ? void 0 : nodeData.rowCount) === "number" ? nodeData.rowCount : void 0;
+		const color = (_getFieldString5 = getFieldString(componentFields, "Color")) !== null && _getFieldString5 !== void 0 ? _getFieldString5 : pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.color);
+		return buildDetailedLabel([
+			participantName ? `SequenceParticipant: ${participantName}` : "SequenceParticipant",
+			...typeof rowCount === "number" ? [`rows: ${rowCount}`] : [],
+			...color ? [`color: ${color}`] : [],
+			...buildFieldLines(componentFields, new Set([
+				"name",
+				"label",
+				"color"
+			]))
+		]);
+	}
+	if (nodeType === "comment") return buildDetailedLabel([`Comment: ${(typeof (nodeData === null || nodeData === void 0 ? void 0 : nodeData.isResolved) === "boolean" ? nodeData.isResolved : void 0) ? "Resolved" : "Open"}`, ...buildFieldLines(componentFields, new Set(["name"]))]);
+	if (nodeType === "builder") {
+		const componentId = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.componentId);
+		return buildDetailedLabel([
+			name ? `Builder: ${name}` : "Builder",
+			...componentId ? [`componentId: ${componentId}`] : [],
+			...buildFieldLines(componentFields, new Set(["name"]))
+		]);
+	}
+	const baseLabel = resolveMermaidNodeLabel(node);
+	if (baseLabel) {
+		const lines = [`${nodeType ? nodeType.charAt(0).toUpperCase() + nodeType.slice(1) : "Node"}: ${baseLabel}`];
+		lines.push(...buildFieldLines(componentFields, new Set([
+			"name",
+			"text",
+			"code"
+		])));
+		return buildDetailedLabel(lines);
+	}
+	const fallbackLabel = pickString(nodeData === null || nodeData === void 0 ? void 0 : nodeData.label);
+	if (fallbackLabel) return `${nodeType ? nodeType.charAt(0).toUpperCase() + nodeType.slice(1) : "Node"}: ${fallbackLabel}`;
+}
+function escapeMermaidEdgeLabelText(value) {
+	return value.replaceAll("|", "/").replace(/\s+/g, " ").trim();
+}
+function resolveMermaidEdgeLabel(edge) {
+	return pickString(edge.label);
+}
+function buildMermaidNodeLines(graphNodes, nodeIdMap, detailedContext) {
+	return graphNodes.map((node) => {
+		var _nodeIdMap$get;
+		const mappedNodeId = (_nodeIdMap$get = nodeIdMap.get(node.id)) !== null && _nodeIdMap$get !== void 0 ? _nodeIdMap$get : node.id;
+		const mermaidLabel = detailedContext ? resolveMermaidDetailedNodeLabel(node) : resolveMermaidNodeLabel(node);
+		if (!mermaidLabel) return mappedNodeId;
+		if (detailedContext) {
+			const normalizedDetailedLabel = normalizeDetailedMermaidLabel(mermaidLabel);
+			if (!normalizedDetailedLabel) return mappedNodeId;
+			return `${mappedNodeId}["${escapeMermaidText(normalizedDetailedLabel)}"]`;
+		}
+		if (!canInlineMermaidLabel(mermaidLabel)) return mappedNodeId;
+		return `${mappedNodeId}["${escapeMermaidText(mermaidLabel)}"]`;
+	});
+}
+function buildMermaidEdgeLines(edges, nodeIdMap, detailedContext) {
+	const mermaidEdgeLines = [];
+	for (const edge of edges) {
+		const source = nodeIdMap.get(edge.source);
+		const target = nodeIdMap.get(edge.target);
+		if (!source || !target) continue;
+		if (detailedContext) {
+			const mermaidEdgeLabel = resolveMermaidEdgeLabel(edge);
+			if (mermaidEdgeLabel) {
+				mermaidEdgeLines.push(`${source} -->|${escapeMermaidEdgeLabelText(mermaidEdgeLabel)}| ${target}`);
+				continue;
+			}
+		}
+		mermaidEdgeLines.push(`${source} --> ${target}`);
+	}
+	return mermaidEdgeLines;
+}
+function convertUiGraphToMermaid(input, options) {
+	const groupNodes = input.nodes.filter((node) => node.type === "group");
+	const graphNodes = input.nodes.filter((node) => node.type !== "group");
+	const direction = inferDirection(graphNodes, input.edges);
+	const nodeIdMap = buildNodeIdMap(graphNodes);
+	const mermaidNodeLines = buildMermaidNodeLines(graphNodes, nodeIdMap, (options === null || options === void 0 ? void 0 : options.detailedContext) === true);
+	const mermaidEdgeLines = buildMermaidEdgeLines(input.edges, nodeIdMap, (options === null || options === void 0 ? void 0 : options.detailedContext) === true);
+	const context = buildValidatedContext(graphNodes, input.edges, groupNodes, nodeIdMap);
+	return {
+		mermaid: [
+			`flowchart ${direction}`,
+			...mermaidNodeLines,
+			...mermaidEdgeLines
+		].join("\n"),
+		context
+	};
+}
+export { AstToSqlGenerator, AstToUiConverter, BasicDetailsSchema, ComponentInputType, DialectIdSchema, DocumentCollectionSchema, DocumentIndexSchema, DynamoAttributeSchema, DynamoEditorSchema, DynamoGsiSchema, EditorSupportedDialectSchema, JsonEditorSchema, MongoCollectionSchema, MongoEditorSchema, MongoIndexFieldSchema, MongoIndexSchema, MongoNestedFieldSchema, NestedFieldSchema, NoSqlFieldSchema, SqlToAstParser, buildMetaData, contextSchema, convertDynamoSchemaToAst, convertJsonSchemaToAst, convertMermaidToReactFlow, convertMermaidToReactFlowWithContext, convertMongoSchemaToAst, convertNoSQLToAst, convertUiGraphToMermaid, flattenMetaData, generateTableNodeId, generateUUID, sanitizeMermaidLabels, syncBaseData };