biz-a-cli 2.3.79 → 2.3.80-15224

package/engine/domain/appConfig.js

@@ -0,0 +1,2342 @@
+import axios from "axios";
+import { IDLE_SOCKET_TIMEOUT_MILLISECONDS } from "../../bin/hubEvent.js";
+import { queryData, executeBlock, getGlobalConfig } from "../../db/db.js";
+import * as firebirdDdl from "./firebird-ddl.js";
+
+export const TBL_SYS_CONFIG = "SYS$CONFIG";
+export const APP_CONFIG_NAME = "APPLICATION_CONFIG";
+export const DOMAIN_CONFIG_NAME = "DOMAIN_CONFIG";
+
+const FINA_METHOD_CLASS = "TFinaMethod";
+
+const escapeQuote = (value) => {
+	return (value || "").replace(/'/g, "''");
+};
+
+const toSingleLine = (value) => {
+	return String(value ?? "")
+		.replace(/[\r\n]+/g, " ")
+		.replace(/\s{2,}/g, " ")
+		.trim();
+};
+
+const sanitizeSql = (sql) => {
+	return toSingleLine(sql ?? "");
+};
+
+const toSimpleHash = (input) => {
+	let hash = 0;
+	for (let index = 0; index < input.length; index++) {
+		hash = (hash << 5) - hash + input.charCodeAt(index);
+		hash |= 0;
+	}
+	return Math.abs(hash).toString(16).toUpperCase();
+};
+
+const toConstraintIdentifierPart = (identifier) => {
+	const normalized = String(identifier ?? "")
+		.replace(/^"|"$/g, "")
+		.toUpperCase()
+		.replace(/[^A-Z0-9_$]+/g, "_")
+		.replace(/^_+|_+$/g, "");
+	return normalized || "COL";
+};
+
+const buildFirebird25NotNullCheckName = (tableIdentifier, columnIdentifier) => {
+	const baseName = [
+		"CK",
+		toConstraintIdentifierPart(tableIdentifier),
+		toConstraintIdentifierPart(columnIdentifier),
+		"NN",
+	]
+		.filter((part) => part.length > 0)
+		.join("_");
+	if (baseName.length <= 31) {
+		return baseName;
+	}
+
+	const suffix = toSimpleHash(baseName).slice(0, 6);
+	const prefixLength = Math.max(1, 31 - suffix.length - 1);
+	return `${baseName.slice(0, prefixLength)}_${suffix}`;
+};
+
+const toDbName = (value) => {
+	const source = String(value ?? "");
+	// Skip the camelCase->snake_case split for already-uppercase input (e.g. a hash-suffixed
+	// name this function itself already produced) -- otherwise a hex hash like "1E8A9B" gets
+	// spurious underscores inserted at digit->letter boundaries ("1_E8_A9_B"), pushing an
+	// already-valid 31-char identifier over the limit and forcing a second, different hash.
+	const withWordBreaks = /[a-z]/.test(source) ? source.replace(/([a-z0-9])([A-Z])/g, "$1_$2") : source;
+	const normalized = withWordBreaks
+		.replace(/[^A-Za-z0-9]+/g, "_")
+		.replace(/_+/g, "_")
+		.replace(/^_+|_+$/g, "")
+		.toUpperCase();
+
+	const raw = normalized || "COL";
+	if (raw.length <= 31) {
+		return raw;
+	}
+
+	const hash = toSimpleHash(raw).slice(0, 6);
+	const leadingLength = 31 - hash.length - 1;
+	// Strip a trailing underscore left by the slice so we never emit a double underscore before
+	// the hash -- a lone trailing "_" here would otherwise get silently collapsed by any later
+	// re-normalization pass, producing a different identifier than this function itself stored.
+	return `${raw.slice(0, leadingLength).replace(/_+$/, "")}_${hash}`;
+};
+
+const buildObjectName = (prefix, ...parts) => {
+	const raw = [toDbName(prefix), ...parts.map((part) => toDbName(part))]
+		.filter((part) => part.length > 0)
+		.join("_");
+
+	if (raw.length <= 31) {
+		return raw;
+	}
+
+	const hash = toSimpleHash(raw).slice(0, 6);
+	const leadingLength = 31 - hash.length - 1;
+	// Same trailing-underscore guard as toDbName above -- keeps this idempotent under re-normalization.
+	return `${raw.slice(0, leadingLength).replace(/_+$/, "")}_${hash}`;
+};
+
+const normalizeExpression = (expression) => {
+	return String(expression ?? "")
+		.replace(/\s+/g, " ")
+		.trim()
+		.toUpperCase();
+};
+
+const toSqlLiteral = (value) => {
+	if (value === null) {
+		return "NULL";
+	}
+	if (typeof value === "number") {
+		return `${value}`;
+	}
+	if (typeof value === "boolean") {
+		return value ? "1" : "0";
+	}
+	return `'${String(value).replace(/'/g, "''")}'`;
+};
+
+const toPositiveInteger = (value) => {
+	const n = Number(value);
+	return Number.isInteger(n) && n > 0 ? n : undefined;
+};
+
+const toNonNegativeInteger = (value) => {
+	const n = Number(value);
+	return Number.isInteger(n) && n >= 0 ? n : undefined;
+};
+
+const getBaseColumns = () => {
+	return [
+		{ data: `${TBL_SYS_CONFIG}.ID`, key: "id" },
+		{ data: `${TBL_SYS_CONFIG}.NAME`, key: "name" },
+		{ data: `${TBL_SYS_CONFIG}.DATA`, key: "data" },
+	];
+};
+
+export const getConfigByNameParameters = (name) => {
+	return {
+		start: 0,
+		length: 1,
+		order: [],
+		filter: [
+			{
+				junction: "",
+				column: "NAME",
+				operator: "=",
+				value1: `'${escapeQuote(name)}'`,
+			},
+		],
+		columns: getBaseColumns(),
+	};
+};
+
+export const getConfigByNameVersionParameters = (name, version) => {
+	return {
+		start: 0,
+		length: 1,
+		order: [],
+		filter: [
+			{
+				junction: "",
+				column: "NAME",
+				operator: "=",
+				value1: `'${escapeQuote(name)}'`,
+			},
+			{
+				junction: "AND",
+				column: "VERSION",
+				operator: "=",
+				value1: `'${escapeQuote(version)}'`,
+			},
+		],
+		columns: [...getBaseColumns(), { data: `${TBL_SYS_CONFIG}.VERSION`, key: "version" }],
+	};
+};
+
+const buildUpsertBlockSql = (escapedName, escapedVersion, escapedContent, appendOnUpdate) => {
+	const updateDataClause = appendOnUpdate
+		? `      SET DATA = COALESCE(DATA, '') || '${escapedContent}' `
+		: `      SET DATA = '${escapedContent}' `;
+
+	return (
+		"" +
+		"EXECUTE BLOCK " +
+		"RETURNS ( " +
+		"   RESULT VARCHAR(6), " +
+		"   CONFIG_ID INTEGER " +
+		") AS " +
+		"   DECLARE VARIABLE EXISTING_ID INTEGER; " +
+		"BEGIN " +
+		"   EXISTING_ID = NULL; " +
+		`   SELECT FIRST 1 C.ID FROM ${TBL_SYS_CONFIG} C ` +
+		`   WHERE C.NAME = '${escapedName}' AND COALESCE(C.VERSION, '') = '${escapedVersion}' ` +
+		"   ORDER BY C.ID DESC " +
+		"   INTO :EXISTING_ID; " +
+		"   IF (EXISTING_ID IS NULL) THEN BEGIN " +
+		`      INSERT INTO ${TBL_SYS_CONFIG} (NAME, VERSION, DATA) VALUES('${escapedName}', '${escapedVersion}', '${escapedContent}') ` +
+		"      RETURNING ID INTO :CONFIG_ID; " +
+		"   END ELSE BEGIN " +
+		`      UPDATE ${TBL_SYS_CONFIG} ` +
+		updateDataClause +
+		"      WHERE ID = :EXISTING_ID; " +
+		"      CONFIG_ID = EXISTING_ID; " +
+		"   END " +
+		"   RESULT = 'UPSERT'; " +
+		"   SUSPEND; " +
+		"END;"
+	);
+};
+
+export const getUpsertBlock = (name, version, content) => {
+	const escapedName = escapeQuote(toSingleLine(name));
+	const escapedVersion = escapeQuote(toSingleLine(version ?? ""));
+	const escapedContent = escapeQuote(toSingleLine(content ?? ""));
+	return buildUpsertBlockSql(escapedName, escapedVersion, escapedContent, false);
+};
+
+const splitContentBySize = (content, chunkSize) => {
+	const normalizedChunkSize =
+		Number.isFinite(chunkSize) && chunkSize > 0 ? Math.floor(chunkSize) : 2 ** 16;
+	if (!content) {
+		return [""];
+	}
+
+	const chunks = [];
+	for (let index = 0; index < content.length; index += normalizedChunkSize) {
+		chunks.push(content.slice(index, index + normalizedChunkSize));
+	}
+	return chunks;
+};
+
+export const getChunkedUpsertBlocks = (name, version, content, chunkSize = 2 ** 16) => {
+	const escapedName = escapeQuote(toSingleLine(name));
+	const escapedVersion = escapeQuote(toSingleLine(version ?? ""));
+	const normalizedContent = toSingleLine(content ?? "");
+	const contentChunks = splitContentBySize(normalizedContent, chunkSize);
+
+	return contentChunks.map((chunk, index) =>
+		buildUpsertBlockSql(escapedName, escapedVersion, escapeQuote(chunk), index > 0),
+	);
+};
+
+const extractObjectLiteral = (source, startIndex) => {
+	let depth = 0;
+	let quote = "";
+	let escaped = false;
+
+	for (let index = startIndex; index < source.length; index++) {
+		const ch = source[index];
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === quote) {
+				quote = "";
+			}
+			continue;
+		}
+
+		if (ch === '"' || ch === "'" || ch === "`") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "{") {
+			depth += 1;
+			continue;
+		}
+		if (ch === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				return source.slice(startIndex, index + 1);
+			}
+		}
+	}
+
+	return undefined;
+};
+
+const extractReturnedObjectLiteral = (source, scopeToken) => {
+	const scopeStart = scopeToken ? source.indexOf(scopeToken) : 0;
+	const startIndex = scopeStart >= 0 ? scopeStart : 0;
+	const returnIndex = source.indexOf("return", startIndex);
+	if (returnIndex < 0) {
+		return undefined;
+	}
+
+	const braceIndex = source.indexOf("{", returnIndex);
+	if (braceIndex < 0) {
+		return undefined;
+	}
+
+	return extractObjectLiteral(source, braceIndex);
+};
+
+const isLegacyDomainConfigShape = (parsed) => {
+	const root = parsed;
+	return !!(
+		root &&
+		typeof root === "object" &&
+		(Object.prototype.hasOwnProperty.call(root, "tableName") ||
+			Object.prototype.hasOwnProperty.call(root, "fields") ||
+			Object.prototype.hasOwnProperty.call(root, "functions"))
+	);
+};
+
+export const parseConfigForVersion = (configContent) => {
+	const raw = (configContent ?? "").trim();
+	if (!raw) {
+		return {};
+	}
+
+	try {
+		return JSON.parse(raw);
+	} catch {
+		const configObjLiteral = extractReturnedObjectLiteral(raw, "get");
+		if (!configObjLiteral) {
+			throw new Error("Invalid config JSON/object.");
+		}
+
+		try {
+			return Function(`"use strict"; return (${configObjLiteral});`)();
+		} catch {
+			throw new Error("Invalid config object literal.");
+		}
+	}
+};
+
+export const parseDomainConfig = (domainConfigContent) => {
+	const raw = (domainConfigContent ?? "").trim();
+	if (!raw) {
+		return {};
+	}
+
+	try {
+		return JSON.parse(raw);
+	} catch {
+		const configObjLiteral = extractReturnedObjectLiteral(raw, "get");
+		if (!configObjLiteral) {
+			throw new Error("Invalid domain config JSON/object.");
+		}
+
+		try {
+			const parsed = Function(`"use strict"; return (${configObjLiteral});`)();
+			if (isLegacyDomainConfigShape(parsed)) {
+				throw new Error(
+					"Legacy domain config format is not supported. Use get(){ return { metadata, model, ui } }.",
+				);
+			}
+			return parsed;
+		} catch (error) {
+			if (String(error?.message ?? "").includes("Legacy domain config format is not supported")) {
+				throw error;
+			}
+			throw new Error("Invalid domain config object literal.");
+		}
+	}
+};
+
+export const extractConfigVersion = (configContent) => {
+	const parsed = parseConfigForVersion(configContent);
+	const version = parsed?.metadata?.version;
+	if (version == null) {
+		return null;
+	}
+
+	const trimmedVersion = String(version).trim();
+	return trimmedVersion.length > 0 ? trimmedVersion : null;
+};
+
+export const isSemanticVersion = (version) => {
+	return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/.test(String(version ?? "").trim());
+};
+
+export const buildTableStructureQueries = (tableName) => {
+	return firebirdDdl.buildTableStructureQueries(tableName);
+};
+
+export const buildStructureSnapshotFromRows = (input) => {
+	return firebirdDdl.buildStructureSnapshotFromRows(input);
+};
+
+export const compareTableStructure = (expected, actual) => {
+	return firebirdDdl.compareTableStructure(expected, actual);
+};
+
+export const generateCreateTableSql = (table, createIfNotExists = true) => {
+	return firebirdDdl.generateCreateTableSql(table, createIfNotExists);
+};
+
+export const generateCreateSchemaSql = (schema, createIfNotExists = true) => {
+	return firebirdDdl.generateCreateSchemaSql(schema, createIfNotExists);
+};
+
+export const generateExecuteBlockSql = (schema) => {
+	return firebirdDdl.generateExecuteBlockSql(schema);
+};
+
+const hasSameColumnDefinitionForRename = (expected, actual) => {
+	const expectedType = normalizeTypeForCompare(expected.type, expected.size, expected.scale);
+	const actualType = normalizeTypeForCompare(actual.type, actual.size, actual.scale);
+	const expectedDefault = normalizeExpression(
+		expected.defaultExpression ??
+			(expected.defaultValue !== undefined ? toSqlLiteral(expected.defaultValue) : ""),
+	);
+	const actualDefault = normalizeExpression(actual.defaultExpression ?? "");
+	const expectedComputed = normalizeExpression(expected.computedBy ?? "");
+	const actualComputed = normalizeExpression(actual.computedBy ?? "");
+
+	return (
+		expectedType === actualType &&
+		(expected.nullable !== false) === (actual.nullable !== false) &&
+		expectedDefault === actualDefault &&
+		expectedComputed === actualComputed
+	);
+};
+
+const isFirebird25NotNullCheckForColumn = (check, columnName) => {
+	const expression = String(check?.expression ?? "")
+		.replace(/^CHECK\s*/i, "")
+		.replace(/"/g, "")
+		.replace(/\s+/g, "")
+		.toUpperCase();
+	const normalizedColumnName = toConstraintIdentifierPart(columnName);
+	return (
+		expression === `${normalizedColumnName}ISNOTNULL` ||
+		expression === `(${normalizedColumnName}ISNOTNULL)`
+	);
+};
+
+const resolveFirebird25NotNullCheckState = (tableName, columnName, actual) => {
+	const generatedName = buildFirebird25NotNullCheckName(tableName, columnName);
+	const checks = actual.checks ?? [];
+	const hasGeneratedName = checks.some(
+		(check) => check.name.trim().toUpperCase() === generatedName,
+	);
+	const matches = checks.some((check) => isFirebird25NotNullCheckForColumn(check, columnName));
+	return {
+		generatedName,
+		hasGeneratedName,
+		matches,
+	};
+};
+
+const describeColumnDependency = (dependency) => {
+	const dependentName = dependency.dependentName || "unnamed object";
+	return `dependency ${dependentName} (type ${dependency.dependentType})`;
+};
+
+const getColumnRenameBlockers = (actual, columnName) => {
+	const normalizedColumnName = columnName.trim().toUpperCase();
+	const blockers = [];
+	const hasColumn = (columns) =>
+		(columns ?? []).some((column) => column.trim().toUpperCase() === normalizedColumnName);
+
+	if (hasColumn(actual.primaryKey)) {
+		blockers.push("a primary key");
+	}
+	for (const uniqueKey of actual.uniqueKeys ?? []) {
+		if (hasColumn(uniqueKey.columns)) {
+			blockers.push(`unique constraint ${uniqueKey.name}`);
+		}
+	}
+	for (const index of actual.indexes ?? []) {
+		if (hasColumn(index.columns)) {
+			blockers.push(`index ${index.name}`);
+		}
+	}
+	for (const foreignKey of actual.foreignKeys ?? []) {
+		if (hasColumn(foreignKey.columns)) {
+			blockers.push(`foreign key ${foreignKey.name}`);
+		}
+	}
+	for (const foreignKey of actual.incomingForeignKeys ?? []) {
+		if (hasColumn(foreignKey.referenceColumns)) {
+			blockers.push(`incoming foreign key ${foreignKey.name} (${foreignKey.tableName})`);
+		}
+	}
+	for (const dependency of actual.columnDependencies ?? []) {
+		if (dependency.columnName.trim().toUpperCase() === normalizedColumnName) {
+			blockers.push(describeColumnDependency(dependency));
+		}
+	}
+
+	return [...new Set(blockers)];
+};
+
+const normalizeTypeForCompare = (type, size, scale) => {
+	const normalizedType =
+		String(type ?? "").trim().toUpperCase() === "BOOLEAN"
+			? "SMALLINT"
+			: String(type ?? "").trim().toUpperCase();
+
+	const supportsLength = ["CHAR", "VARCHAR"].includes(normalizedType);
+	const supportsPrecision = ["NUMERIC", "DECIMAL"].includes(normalizedType);
+	const hasSize = typeof size === "number" && Number.isFinite(size) && size > 0;
+	const hasScale = typeof scale === "number" && Number.isFinite(scale);
+
+	if (!supportsLength && !supportsPrecision) {
+		return normalizedType;
+	}
+
+	if (!hasSize) {
+		return normalizedType;
+	}
+
+	if (supportsLength) {
+		return `${normalizedType}(${size})`;
+	}
+
+	if (!hasScale || scale === 0) {
+		return `${normalizedType}(${size})`;
+	}
+
+	return `${normalizedType}(${size},${scale})`;
+};
+
+const resolveColumnTypeForAlter = (column) => {
+	const normalizedType =
+		String(column.type ?? "").trim().toUpperCase() === "BOOLEAN"
+			? "SMALLINT"
+			: String(column.type ?? "").trim().toUpperCase();
+
+	const supportsLength = ["CHAR", "VARCHAR"].includes(normalizedType);
+	const supportsPrecision = ["NUMERIC", "DECIMAL"].includes(normalizedType);
+	const hasSize =
+		typeof column.size === "number" && Number.isFinite(column.size) && column.size > 0;
+	const hasScale = typeof column.scale === "number" && Number.isFinite(column.scale);
+
+	if (!supportsLength && !supportsPrecision) {
+		return normalizedType;
+	}
+
+	if (!hasSize) {
+		return normalizedType;
+	}
+
+	if (supportsLength) {
+		return `${normalizedType}(${column.size})`;
+	}
+
+	if (!hasScale || column.scale === 0) {
+		return `${normalizedType}(${column.size})`;
+	}
+
+	return `${normalizedType}(${column.size},${column.scale})`;
+};
+
+const buildColumnDefinitionForAlter = (column) => {
+	const parts = [column.name, resolveColumnTypeForAlter(column)];
+
+	if (column.defaultExpression) {
+		parts.push(`DEFAULT ${column.defaultExpression}`);
+	} else if (column.defaultValue !== undefined) {
+		parts.push(`DEFAULT ${toSqlLiteral(column.defaultValue)}`);
+	}
+
+	if (column.nullable === false) {
+		parts.push("NOT NULL");
+	}
+
+	return parts.join(" ");
+};
+
+const buildCreateIndexStatementForSync = (tableName, index) => {
+	const mode = [index.unique ? "UNIQUE" : "", index.descending ? "DESC" : ""]
+		.filter(Boolean)
+		.join(" ");
+	const modePart = mode.length > 0 ? `${mode} ` : "";
+
+	if (index.expression) {
+		return `CREATE ${modePart}INDEX ${index.name} ON ${tableName} COMPUTED BY (${index.expression});`;
+	}
+
+	return `CREATE ${modePart}INDEX ${index.name} ON ${tableName} (${(index.columns ?? []).join(", ")});`;
+};
+
+export const buildTableSyncPlan = (expected, actual, options) => {
+	const migrationMode = options?.migrationMode ?? "safe";
+	const allowDestructiveChanges = migrationMode === "aggressive";
+	const compare = compareTableStructure(expected, actual);
+	if (compare.isSame) {
+		return { statements: [], warnings: [], differences: [] };
+	}
+
+	const statements = [];
+	const warnings = [];
+
+	const expectedColumns = new Map();
+	for (const col of expected.columns ?? []) {
+		expectedColumns.set(col.name.trim().toUpperCase(), col);
+	}
+	const actualColumns = new Map();
+	for (const col of actual.columns ?? []) {
+		actualColumns.set(col.name.trim().toUpperCase(), col);
+	}
+
+	const unmatchedExpectedColumns = [...expectedColumns.entries()].filter(
+		([columnName]) => !actualColumns.has(columnName),
+	);
+	const unmatchedActualColumns = [...actualColumns.entries()].filter(
+		([columnName]) => !expectedColumns.has(columnName),
+	);
+	const handledExpectedColumns = new Set();
+	const handledActualColumns = new Set();
+	const blockedExpectedColumns = new Set();
+	if (
+		unmatchedExpectedColumns.length === 1 &&
+		unmatchedActualColumns.length === 1 &&
+		hasSameColumnDefinitionForRename(unmatchedExpectedColumns[0][1], unmatchedActualColumns[0][1])
+	) {
+		const [expectedColumnName, expectedColumn] = unmatchedExpectedColumns[0];
+		const [actualColumnName, actualColumn] = unmatchedActualColumns[0];
+		const blockers = getColumnRenameBlockers(actual, actualColumnName);
+		handledExpectedColumns.add(expectedColumnName);
+		handledActualColumns.add(actualColumnName);
+		if (blockers.length > 0) {
+			blockedExpectedColumns.add(expectedColumnName);
+			warnings.push(
+				`Column "${actualColumn.name}" cannot be renamed to "${expectedColumn.name}" in table ${expected.name} because it has ${blockers.join(", ")}; requires manual migration.`,
+			);
+		} else {
+			statements.push(
+				`ALTER TABLE ${expected.name} ALTER COLUMN ${actualColumn.name} TO ${expectedColumn.name};`,
+			);
+		}
+	} else if (
+		unmatchedExpectedColumns.length > 0 &&
+		unmatchedActualColumns.length > 0 &&
+		(unmatchedExpectedColumns.length > 1 || unmatchedActualColumns.length > 1)
+	) {
+		warnings.push(`Ambiguous column rename candidates for table ${expected.name}; requires manual migration.`);
+	}
+
+	for (const [columnName, expectedColumn] of expectedColumns.entries()) {
+		const actualColumn = actualColumns.get(columnName);
+		if (!actualColumn) {
+			if (handledExpectedColumns.has(columnName)) {
+				continue;
+			}
+			statements.push(
+				`ALTER TABLE ${expected.name} ADD ${buildColumnDefinitionForAlter(expectedColumn)};`,
+			);
+			continue;
+		}
+
+		const expectedType = normalizeTypeForCompare(expectedColumn.type, expectedColumn.size, expectedColumn.scale);
+		const actualType = normalizeTypeForCompare(actualColumn.type, actualColumn.size, actualColumn.scale);
+		if (expectedType !== actualType) {
+			statements.push(
+				`ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} TYPE ${resolveColumnTypeForAlter(expectedColumn)};`,
+			);
+		}
+
+		const expectedNullable = expectedColumn.nullable !== false;
+		const firebird25NotNullCheck = resolveFirebird25NotNullCheckState(expected.name, expectedColumn.name, actual);
+		const actualNullable =
+			expectedNullable || !firebird25NotNullCheck.matches
+				? actualColumn.nullable !== false
+				: false;
+		if (expectedNullable !== actualNullable) {
+			if (!expectedNullable && firebird25NotNullCheck.hasGeneratedName && !firebird25NotNullCheck.matches) {
+				warnings.push(
+					`Constraint "${firebird25NotNullCheck.generatedName}" already exists on table ${expected.name} but does not enforce ${expectedColumn.name} IS NOT NULL; requires manual migration.`,
+				);
+			} else {
+				statements.push(
+					expectedNullable
+						? `ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} DROP NOT NULL;`
+						: `ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} SET NOT NULL;`,
+				);
+			}
+		}
+
+		const expectedDefault = normalizeExpression(
+			expectedColumn.defaultExpression ??
+				(expectedColumn.defaultValue !== undefined ? toSqlLiteral(expectedColumn.defaultValue) : ""),
+		);
+		const actualDefault = normalizeExpression(actualColumn.defaultExpression ?? "");
+		if (expectedDefault !== actualDefault) {
+			if (expectedColumn.defaultExpression) {
+				statements.push(
+					`ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} SET DEFAULT ${expectedColumn.defaultExpression};`,
+				);
+			} else if (expectedColumn.defaultValue !== undefined) {
+				statements.push(
+					`ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} SET DEFAULT ${toSqlLiteral(expectedColumn.defaultValue)};`,
+				);
+			} else {
+				statements.push(`ALTER TABLE ${expected.name} ALTER COLUMN ${expectedColumn.name} DROP DEFAULT;`);
+			}
+		}
+	}
+
+	const actualPkColumns = new Set((actual.primaryKey ?? []).map((v) => v.trim().toUpperCase()));
+	const incomingForeignKeys = actual.incomingForeignKeys ?? [];
+	for (const [columnName, actualColumn] of actualColumns.entries()) {
+		if (expectedColumns.has(columnName) || handledActualColumns.has(columnName)) {
+			continue;
+		}
+
+		if (!allowDestructiveChanges) {
+			warnings.push(`Column "${columnName}" exists in actual table ${expected.name} but is not dropped in safe mode.`);
+			continue;
+		}
+
+		if (actualPkColumns.has(columnName)) {
+			warnings.push(`Column "${columnName}" is part of primary key in table ${expected.name} requires manual drop.`);
+			continue;
+		}
+
+		const incomingReferences = incomingForeignKeys.filter((fk) =>
+			(fk.referenceColumns ?? []).some((col) => col.trim().toUpperCase() === columnName),
+		);
+		if (incomingReferences.length > 0) {
+			const incomingReferenceNames = incomingReferences.map((fk) => `${fk.name} (${fk.tableName})`).join(", ");
+			warnings.push(
+				`Column "${columnName}" is referenced by foreign keys ${incomingReferenceNames} in table ${expected.name} and requires manual migration.`,
+			);
+			continue;
+		}
+
+		for (const fk of actual.foreignKeys ?? []) {
+			if ((fk.columns ?? []).some((col) => col.trim().toUpperCase() === columnName)) {
+				statements.push(`ALTER TABLE ${expected.name} DROP CONSTRAINT ${fk.name};`);
+			}
+		}
+
+		for (const uniqueKey of actual.uniqueKeys ?? []) {
+			if ((uniqueKey.columns ?? []).some((col) => col.trim().toUpperCase() === columnName)) {
+				statements.push(`ALTER TABLE ${expected.name} DROP CONSTRAINT ${uniqueKey.name};`);
+			}
+		}
+
+		for (const index of actual.indexes ?? []) {
+			if ((index.columns ?? []).some((col) => col.trim().toUpperCase() === columnName)) {
+				statements.push(`DROP INDEX ${index.name};`);
+			}
+		}
+
+		statements.push(`ALTER TABLE ${expected.name} DROP ${actualColumn.name};`);
+	}
+
+	const expectedPk = (expected.primaryKey?.columns ?? []).map((v) => v.trim().toUpperCase());
+	const actualPk = (actual.primaryKey ?? []).map((v) => v.trim().toUpperCase());
+	const expectedPkIsBlocked = expectedPk.some((columnName) => blockedExpectedColumns.has(columnName));
+	if (!expectedPkIsBlocked && expectedPk.length > 0 && actualPk.length === 0) {
+		const pkName = expected.primaryKey?.name ?? buildObjectName("PK", expected.name);
+		statements.push(`ALTER TABLE ${expected.name} ADD CONSTRAINT ${pkName} PRIMARY KEY (${expectedPk.join(", ")});`);
+	} else if (!expectedPkIsBlocked && expectedPk.length > 0 && expectedPk.join("|") !== actualPk.join("|")) {
+		warnings.push(`Primary key mismatch for table ${expected.name} requires manual migration.`);
+	}
+
+	const actualUnique = new Set((actual.uniqueKeys ?? []).map((u) => u.name.trim().toUpperCase()));
+	for (const uniqueKey of expected.uniqueKeys ?? []) {
+		if ((uniqueKey.columns ?? []).some((columnName) => blockedExpectedColumns.has(columnName.trim().toUpperCase()))) {
+			continue;
+		}
+		if (!actualUnique.has(uniqueKey.name.trim().toUpperCase())) {
+			statements.push(
+				`ALTER TABLE ${expected.name} ADD CONSTRAINT ${uniqueKey.name} UNIQUE (${uniqueKey.columns.join(", ")});`,
+			);
+		}
+	}
+
+	const actualIndexes = new Map();
+	for (const idx of actual.indexes ?? []) {
+		actualIndexes.set(idx.name.trim().toUpperCase(), idx);
+	}
+	for (const index of expected.indexes ?? []) {
+		if ((index.columns ?? []).some((columnName) => blockedExpectedColumns.has(columnName.trim().toUpperCase()))) {
+			continue;
+		}
+		const actualIndex = actualIndexes.get(index.name.trim().toUpperCase());
+		if (!actualIndex) {
+			statements.push(buildCreateIndexStatementForSync(expected.name, index));
+			continue;
+		}
+
+		const expectedColumnsKey = (index.columns ?? []).map((v) => v.trim().toUpperCase()).join("|");
+		const actualColumnsKey = (actualIndex.columns ?? []).map((v) => v.trim().toUpperCase()).join("|");
+		const expectedExpr = normalizeExpression(index.expression ?? "");
+		const actualExpr = normalizeExpression(actualIndex.expression ?? "");
+		const expectedUnique = index.unique === true;
+		const actualUniqueFlag = actualIndex.unique === true;
+		const expectedDesc = index.descending === true;
+		const actualDesc = actualIndex.descending === true;
+		if (
+			expectedColumnsKey !== actualColumnsKey ||
+			expectedExpr !== actualExpr ||
+			expectedUnique !== actualUniqueFlag ||
+			expectedDesc !== actualDesc
+		) {
+			warnings.push(`Index ${index.name} mismatch on table ${expected.name} requires manual recreate.`);
+		}
+	}
+
+	const actualFks = new Map();
+	for (const fk of actual.foreignKeys ?? []) {
+		actualFks.set(fk.name.trim().toUpperCase(), fk);
+	}
+	for (const fk of expected.foreignKeys ?? []) {
+		if ((fk.columns ?? []).some((columnName) => blockedExpectedColumns.has(columnName.trim().toUpperCase()))) {
+			continue;
+		}
+		if (!actualFks.has(fk.name.trim().toUpperCase())) {
+			const onDelete = fk.onDelete ? ` ON DELETE ${fk.onDelete}` : "";
+			const onUpdate = fk.onUpdate ? ` ON UPDATE ${fk.onUpdate}` : "";
+			statements.push(
+				`ALTER TABLE ${expected.name} ADD CONSTRAINT ${fk.name} FOREIGN KEY (${fk.columns.join(", ")}) REFERENCES ${fk.referenceTable} (${fk.referenceColumns.join(", ")})${onDelete}${onUpdate};`,
+			);
+		}
+	}
+
+	return {
+		statements: [...new Set(statements.map((statement) => toSingleLine(statement)))],
+		warnings,
+		differences: compare.differences,
+	};
+};
+
+export const buildGeneratorStructureQueries = (table) => {
+	const generatorName = toDbName(table.generatorName ?? buildObjectName(table.name, "GEN"));
+	const triggerName = toDbName(table.triggerName ?? buildObjectName(table.name, "BI"));
+
+	return {
+		generatorExistsSql: [
+			"SELECT COUNT(*) AS GENERATOR_EXISTS",
+			"FROM RDB$GENERATORS G",
+			`WHERE UPPER(TRIM(G.RDB$GENERATOR_NAME)) = '${generatorName}';`,
+		].join(" "),
+		triggerSql: [
+			"SELECT COUNT(*) AS TRIGGER_EXISTS",
+			"FROM RDB$TRIGGERS T",
+			`WHERE UPPER(TRIM(T.RDB$TRIGGER_NAME)) = '${triggerName}'`,
+			"  AND COALESCE(T.RDB$SYSTEM_FLAG, 0) = 0;",
+		].join(" "),
+	};
+};
+
+const resolveIdentityColumnForGeneratorSync = (table) => {
+	const candidates = [];
+	const explicitIdentity = toDbName(table.identityColumnName ?? "");
+	const primaryKeyIdentity = toDbName(table.primaryKey?.columns?.[0] ?? "");
+
+	if (explicitIdentity) {
+		candidates.push(explicitIdentity);
+	}
+	if (primaryKeyIdentity && !candidates.includes(primaryKeyIdentity)) {
+		candidates.push(primaryKeyIdentity);
+	}
+	if (!candidates.includes("ID")) {
+		candidates.push("ID");
+	}
+
+	for (const candidate of candidates) {
+		const column = (table.columns ?? []).find((item) => toDbName(item.name) === candidate);
+		if (column) {
+			return candidate;
+		}
+	}
+
+	return "";
+};
+
+export const shouldSyncGenerator = (table) => {
+	return !!resolveIdentityColumnForGeneratorSync(table);
+};
+
+const resolveIdentityValueExpression = (table, identityColumn, generatorName) => {
+	if (table?.identityGuid) {
+		return "'{' || UUID_TO_CHAR(GEN_UUID()) || '}'";
+	}
+	return `GEN_ID(${generatorName}, 1)`;
+};
+
+const buildCreateIdentityTriggerStatementForSync = (tableName, triggerName, identityColumn, valueExpression) => {
+	return [
+		`CREATE TRIGGER ${triggerName} FOR ${toDbName(tableName)} ACTIVE`,
+		"BEFORE INSERT POSITION 0 AS BEGIN",
+		`IF (NEW.${identityColumn} IS NULL) THEN NEW.${identityColumn} = ${valueExpression};`,
+		"END",
+	].join(" ");
+};
+
+const buildAlterIdentityTriggerStatementForSync = (triggerName, identityColumn, valueExpression) => {
+	return [
+		`ALTER TRIGGER ${triggerName} ACTIVE`,
+		"BEFORE INSERT POSITION 0 AS BEGIN",
+		`IF (NEW.${identityColumn} IS NULL) THEN NEW.${identityColumn} = ${valueExpression};`,
+		"END",
+	].join(" ");
+};
+
+const isIdentityTriggerStructureSame = (triggerSource, identityColumn, valueExpression) => {
+	const normalized = String(triggerSource ?? "")
+		.replace(/\s+/g, "")
+		.toUpperCase();
+	const expectedColumnToken = `NEW.${identityColumn.toUpperCase()}ISNULL`;
+	const expectedValueToken = valueExpression.replace(/\s+/g, "").toUpperCase();
+
+	return normalized.includes(expectedValueToken) && normalized.includes(expectedColumnToken);
+};
+
+export const buildGeneratorSyncPlan = (table, generatorRows, triggerRows) => {
+	const identityColumn = resolveIdentityColumnForGeneratorSync(table);
+	if (!identityColumn) {
+		return { statements: [], differences: [] };
+	}
+
+	const generatorName = toDbName(table.generatorName ?? buildObjectName(table.name, "GEN"));
+	const triggerName = toDbName(table.triggerName ?? buildObjectName(table.name, "BI"));
+	const identityValueExpression = resolveIdentityValueExpression(table, identityColumn, generatorName);
+	const differences = [];
+	const statements = [];
+
+	const generatorExists =
+		Number(generatorRows?.[0]?.["GENERATOR_EXISTS"] ?? generatorRows?.[0]?.["generator_exists"] ?? 0) === 1;
+
+	const triggerExistsRaw = triggerRows?.[0]?.["TRIGGER_EXISTS"] ?? triggerRows?.[0]?.["trigger_exists"];
+	const triggerExists = triggerExistsRaw != null ? Number(triggerExistsRaw) === 1 : undefined;
+	const triggerSource = String(
+		triggerRows?.[0]?.["TRIGGER_SOURCE"] ?? triggerRows?.[0]?.["trigger_source"] ?? "",
+	).trim();
+
+	if (!table?.identityGuid && !generatorExists) {
+		differences.push(`Generator "${generatorName}" is missing.`);
+		statements.push(`CREATE GENERATOR ${generatorName};`);
+	}
+
+	if (triggerExists === false || (triggerExists == null && !triggerSource)) {
+		differences.push(`Trigger "${triggerName}" is missing.`);
+		statements.push(
+			buildCreateIdentityTriggerStatementForSync(table.name, triggerName, identityColumn, identityValueExpression),
+		);
+	} else if (triggerExists === true && !triggerSource) {
+		statements.push(buildAlterIdentityTriggerStatementForSync(triggerName, identityColumn, identityValueExpression));
+	} else if (triggerSource && !isIdentityTriggerStructureSame(triggerSource, identityColumn, identityValueExpression)) {
+		differences.push(`Trigger "${triggerName}" structure mismatch.`);
+		statements.push(buildAlterIdentityTriggerStatementForSync(triggerName, identityColumn, identityValueExpression));
+	}
+
+	return {
+		statements: [...new Set(statements.map((statement) => toSingleLine(statement)))],
+		differences,
+	};
+};
+
+export const buildDomainDdlPreview = (domainConfigContent, defaultDbIndex) => {
+	const buildResult = buildDomainSchemaInternal(domainConfigContent, defaultDbIndex);
+	const schema = buildResult.schema;
+	return {
+		schema,
+		ddlSql: schema.tables.length > 0 ? generateCreateSchemaSql(schema, true) : "",
+		executeBlockSql: schema.tables.length > 0 ? generateExecuteBlockSql(schema) : "",
+		normalizedRelationships: buildResult.normalizedRelationships,
+		warnings: buildResult.warnings,
+	};
+};
+
+export const orderTablesByDependency = (tables) => {
+	const entries = (tables ?? []).map((table, index) => ({
+		table,
+		index,
+		key: toDbName(table.name),
+	}));
+	const entryMap = new Map(entries.map((entry) => [entry.key, entry]));
+	const dependencies = new Map();
+	const dependents = new Map();
+
+	for (const entry of entries) {
+		const deps = new Set();
+		for (const fk of entry.table.foreignKeys ?? []) {
+			const refKey = toDbName(fk.referenceTable);
+			if (refKey && refKey !== entry.key && entryMap.has(refKey)) {
+				deps.add(refKey);
+			}
+		}
+		dependencies.set(entry.key, deps);
+		for (const dep of deps) {
+			if (!dependents.has(dep)) {
+				dependents.set(dep, new Set());
+			}
+			dependents.get(dep).add(entry.key);
+		}
+	}
+
+	const remaining = new Map();
+	for (const entry of entries) {
+		remaining.set(entry.key, dependencies.get(entry.key)?.size ?? 0);
+	}
+
+	const queue = entries
+		.filter((entry) => (remaining.get(entry.key) ?? 0) === 0)
+		.sort((left, right) => left.index - right.index);
+	const ordered = [];
+	const emitted = new Set();
+
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current || emitted.has(current.key)) {
+			continue;
+		}
+		emitted.add(current.key);
+		ordered.push(current.table);
+
+		for (const dependent of dependents.get(current.key) ?? []) {
+			const nextValue = (remaining.get(dependent) ?? 0) - 1;
+			remaining.set(dependent, nextValue);
+			if (nextValue === 0) {
+				const nextEntry = entryMap.get(dependent);
+				if (nextEntry && !emitted.has(nextEntry.key)) {
+					queue.push(nextEntry);
+					queue.sort((left, right) => left.index - right.index);
+				}
+			}
+		}
+	}
+
+	if (ordered.length === entries.length) {
+		return ordered;
+	}
+
+	for (const entry of entries) {
+		if (!emitted.has(entry.key)) {
+			ordered.push(entry.table);
+		}
+	}
+	return ordered;
+};
+
+export const buildDomainSchema = (domainConfigContent, defaultDbIndex) => {
+	return buildDomainSchemaInternal(domainConfigContent, defaultDbIndex).schema;
+};
+
+const resolveDefaultDomainDbIndex = (defaultDbIndex) => {
+	const normalized = toNonNegativeInteger(defaultDbIndex);
+	return normalized ?? 2;
+};
+
+const normalizeDbIndices = (db, defaultDbIndex) => {
+	const fallbackDbIndex = resolveDefaultDomainDbIndex(defaultDbIndex);
+	if (db == null) {
+		return [fallbackDbIndex];
+	}
+
+	if (Array.isArray(db)) {
+		const normalized = db.map((value) => Number(value)).filter((value) => Number.isInteger(value));
+		return normalized.length > 0 ? [...new Set(normalized)] : [fallbackDbIndex];
+	}
+
+	if (typeof db === "string" && db.trim().length === 0) {
+		return [fallbackDbIndex];
+	}
+
+	const singleValue = Number(db);
+	return Number.isInteger(singleValue) ? [singleValue] : [fallbackDbIndex];
+};
+
+const intersectDbIndices = (left, right) => {
+	const set = new Set(right);
+	const result = left.filter((value) => set.has(value));
+	return result.length > 0 ? [...new Set(result)] : [0];
+};
+
+const resolveNullable = (attribute) => {
+	if (typeof attribute?.nullable === "boolean") {
+		return attribute.nullable;
+	}
+	return attribute?.required !== true;
+};
+
+const resolveColumnType = (attribute) => {
+	const rawType = String(attribute?.type ?? "").toLowerCase();
+	const uiIntent = String(attribute?.uiIntent ?? "").toLowerCase();
+	const precision = toPositiveInteger(attribute?.precision ?? attribute?.size);
+	const scale = toNonNegativeInteger(attribute?.scale);
+
+	if (rawType === "number") {
+		const resolvedPrecision = precision ?? 18;
+		const resolvedScale = scale ?? (uiIntent === "currency" ? 2 : 0);
+		if (resolvedScale > 0) {
+			return { type: "NUMERIC", size: resolvedPrecision, scale: resolvedScale };
+		}
+		if (resolvedPrecision <= 9) {
+			return { type: "INTEGER" };
+		}
+		return { type: "BIGINT" };
+	}
+
+	if (rawType === "date") {
+		return { type: "DATE" };
+	}
+
+	if (rawType === "datetime" || rawType === "timestamp" || uiIntent === "datetime") {
+		return { type: "TIMESTAMP" };
+	}
+
+	if (rawType === "boolean") {
+		return { type: "BOOLEAN" };
+	}
+	if (rawType === "blobref") {
+		return { type: "BLOB" };
+	}
+
+	if (rawType === "string") {
+		if (uiIntent === "longtext" || uiIntent === "textarea") {
+			return { type: "BLOB" };
+		}
+		return { type: "VARCHAR", size: precision ?? 120 };
+	}
+
+	return { type: "BLOB" };
+};
+
+const toColumn = (attributeName, rawAttribute) => {
+	const attribute = rawAttribute ?? {};
+	const name = toDbName(attribute?.column ?? attribute?.columnName ?? attributeName);
+	const typeInfo = resolveColumnType(attribute);
+
+	return {
+		name,
+		type: typeInfo.type,
+		...(typeInfo.size != null && { size: typeInfo.size }),
+		...(typeInfo.scale != null && { scale: typeInfo.scale }),
+		nullable: resolveNullable(attribute),
+		...(attribute.defaultExpression && { defaultExpression: String(attribute.defaultExpression) }),
+		...(attribute.defaultValue !== undefined && { defaultValue: attribute.defaultValue }),
+	};
+};
+
+const ensureIdentityPrimaryColumn = (columns, identity) => {
+	const identityPrimaryKey = toDbName(identity?.primaryKey ?? "");
+	if (!identityPrimaryKey) {
+		return;
+	}
+
+	if (columns.some((column) => column.name === identityPrimaryKey)) {
+		return;
+	}
+
+	columns.unshift(
+		identity?.guid
+			? { name: identityPrimaryKey, type: "VARCHAR", size: 38, nullable: false }
+			: { name: identityPrimaryKey, type: "BIGINT", nullable: false },
+	);
+};
+
+const resolvePrimaryKey = (entity, columns) => {
+	const identityKey = entity?.identity?.primaryKey;
+	const identityColumn = identityKey ? toDbName(identityKey) : "";
+
+	if (identityColumn && columns.some((column) => column.name === identityColumn)) {
+		return identityColumn;
+	}
+
+	if (columns.some((column) => column.name === "ID")) {
+		return "ID";
+	}
+
+	return columns[0]?.name;
+};
+
+const buildUniqueKeys = (tableName, attributeEntries, primaryKey) => {
+	return attributeEntries
+		.filter((entry) => entry.attribute?.unique === true && entry.column.name !== primaryKey)
+		.map((entry) => ({
+			name: buildObjectName("UQ", tableName, entry.column.name),
+			columns: [entry.column.name],
+		}));
+};
+
+const hasSameIndexDefinition = (left, right) => {
+	return (
+		(left.columns ?? []).join("|") === (right.columns ?? []).join("|") &&
+		(left.descending === true) === (right.descending === true) &&
+		(left.expression ?? "") === (right.expression ?? "")
+	);
+};
+
+const buildAttributeIndexes = (tableName, attributeEntries, primaryKey, uniqueKeys) => {
+	const indexes = [];
+	const uniqueColumns = new Set(uniqueKeys.map((key) => key.columns[0]));
+
+	for (const entry of attributeEntries) {
+		const columnName = entry.column.name;
+		const uiIntent = String(entry.attribute?.uiIntent ?? "").toLowerCase();
+		const shouldIndex =
+			entry.attribute?.index === true ||
+			uiIntent === "lookup" ||
+			uiIntent === "date" ||
+			uiIntent === "datetime" ||
+			columnName.endsWith("_ID");
+
+		if (!shouldIndex || columnName === primaryKey || uniqueColumns.has(columnName)) {
+			continue;
+		}
+
+		const nextIndex = {
+			name: buildObjectName("IDX", tableName, columnName),
+			columns: [columnName],
+			...(uiIntent === "date" || uiIntent === "datetime" ? { descending: true } : {}),
+		};
+
+		if (!indexes.some((idx) => hasSameIndexDefinition(idx, nextIndex))) {
+			indexes.push(nextIndex);
+		}
+	}
+
+	return indexes;
+};
+
+const buildEntityTable = (entityName, entity, defaultDbIndex) => {
+	const tableName = toDbName(entity?.table ?? entity?.tableName ?? entityName);
+	const dbIndices = normalizeDbIndices(entity?.db, defaultDbIndex);
+	const attributes = entity?.attributes ?? {};
+	const attributeEntries = Object.entries(attributes).map(([attributeName, attribute]) => ({
+		attributeName,
+		attribute: attribute ?? {},
+		column: toColumn(attributeName, attribute),
+	}));
+	const attributeColumns = new Map(
+		attributeEntries.map((entry) => [toDbName(entry.attributeName), entry.column.name]),
+	);
+
+	const identityIsGuid = !!entity?.identity?.guid;
+	const columns = attributeEntries.map((entry) => entry.column);
+	ensureIdentityPrimaryColumn(columns, entity?.identity);
+	const primaryKey = resolvePrimaryKey(entity, columns);
+	const uniqueKeys = buildUniqueKeys(tableName, attributeEntries, primaryKey);
+	const indexes = buildAttributeIndexes(tableName, attributeEntries, primaryKey, uniqueKeys);
+
+	const table = {
+		name: tableName,
+		dbIndex: dbIndices[0],
+		columns,
+		...(primaryKey && { primaryKey: { columns: [primaryKey] } }),
+		...(uniqueKeys.length > 0 && { uniqueKeys }),
+		...(indexes.length > 0 && { indexes }),
+	};
+	const shouldCreateIdentityObjects = !!entity?.identity;
+	if (shouldCreateIdentityObjects && primaryKey) {
+		table.identityColumnName = primaryKey;
+		table.identityGuid = identityIsGuid;
+		if (!identityIsGuid) {
+			table.generatorName = buildObjectName(tableName, "GEN");
+		}
+		table.triggerName = buildObjectName(tableName, "BI");
+	}
+
+	return {
+		entityName,
+		tableName,
+		dbIndices,
+		primaryKey,
+		columns: new Set(columns.map((column) => column.name)),
+		attributeColumns,
+		table,
+	};
+};
+
+const normalizeRelationshipType = (value) => {
+	if (value === "one-to-one" || value === "many-to-many") {
+		return value;
+	}
+	return "one-to-many";
+};
+
+const normalizeOwnership = (value) => {
+	if (value === "parent" || value === "shared" || value === "independent") {
+		return value;
+	}
+	return "shared";
+};
+
+const normalizeJoinStrategy = (explicit, fromDb, toDb) => {
+	if (explicit === "sql" || explicit === "extract" || explicit === "script") {
+		return explicit;
+	}
+
+	return fromDb.some((idx) => toDb.includes(idx)) ? "sql" : "extract";
+};
+
+const normalizeRelationship = (relationshipName, relationship, entityInfos, warnings) => {
+	const fromName = relationship?.from;
+	const toName = relationship?.to;
+	if (!fromName || !toName) {
+		warnings.push(`Relationship "${relationshipName}" ignored: "from" and "to" are required.`);
+		return undefined;
+	}
+
+	const fromInfo = entityInfos.get(fromName);
+	const toInfo = entityInfos.get(toName);
+	if (!fromInfo || !toInfo) {
+		warnings.push(`Relationship "${relationshipName}" ignored: entity "${fromName}" or "${toName}" not found.`);
+		return undefined;
+	}
+
+	const type = normalizeRelationshipType(relationship?.type);
+	const joinType = relationship?.joinType === "outer" ? "outer" : "inner";
+	const ownership = normalizeOwnership(relationship?.ownership);
+	const joinStrategy = normalizeJoinStrategy(relationship?.joinStrategy, fromInfo.dbIndices, toInfo.dbIndices);
+	const parentKey = toDbName(relationship?.parentKey ?? fromInfo.primaryKey ?? "");
+
+	if (type === "many-to-many") {
+		const through = relationship?.through;
+		if (!through?.table || !through?.fromKey || !through?.toKey) {
+			warnings.push(
+				`Relationship "${relationshipName}" ignored: many-to-many requires "through.table/fromKey/toKey".`,
+			);
+			return undefined;
+		}
+
+		return {
+			type,
+			from: fromName,
+			to: toName,
+			joinType,
+			joinStrategy,
+			ownership,
+			parentKey,
+			through: {
+				table: toDbName(through.table),
+				fromKey: toDbName(through.fromKey),
+				toKey: toDbName(through.toKey),
+			},
+			uiIntent: relationship?.uiIntent,
+		};
+	}
+
+	if (!relationship?.foreignKey) {
+		warnings.push(`Relationship "${relationshipName}" ignored: "${type}" requires "foreignKey".`);
+		return undefined;
+	}
+
+	return {
+		type,
+		from: fromName,
+		to: toName,
+		joinType,
+		joinStrategy,
+		ownership,
+		parentKey,
+		foreignKey: toDbName(relationship.foreignKey),
+		uiIntent: relationship?.uiIntent,
+	};
+};
+
+const findColumn = (table, columnName) => {
+	return table.columns.find((column) => column.name === columnName);
+};
+
+const cloneColumn = (source, targetName, nullable) => {
+	return {
+		name: targetName,
+		type: source.type,
+		...(source.size != null && { size: source.size }),
+		...(source.scale != null && { scale: source.scale }),
+		nullable,
+	};
+};
+
+const ensureColumn = (info, column) => {
+	if (info.columns.has(column.name)) {
+		return;
+	}
+	info.columns.add(column.name);
+	info.table.columns = [...info.table.columns, column];
+};
+
+const ensureForeignKey = (table, foreignKey) => {
+	const existing = table.foreignKeys ?? [];
+	if (existing.some((fk) => fk.name === foreignKey.name)) {
+		return;
+	}
+	table.foreignKeys = [...existing, foreignKey];
+};
+
+const ensureIndex = (table, index) => {
+	const existingColumnNames = new Set((table.columns ?? []).map((column) => column.name));
+	const safeColumns = (index.columns ?? []).filter((column) => existingColumnNames.has(column));
+	if (safeColumns.length === 0) {
+		return;
+	}
+
+	const safeIndex = {
+		...index,
+		columns: safeColumns,
+	};
+	const existing = table.indexes ?? [];
+	if (existing.some((idx) => hasSameIndexDefinition(idx, safeIndex))) {
+		return;
+	}
+	table.indexes = [...existing, safeIndex];
+};
+
+const resolveEntityColumnName = (info, key) => {
+	const normalizedKey = toDbName(key);
+	if (info.columns.has(normalizedKey)) {
+		return normalizedKey;
+	}
+	return info.attributeColumns.get(normalizedKey);
+};
+
+const applyDirectRelationship = (relationship, entityInfos, warnings) => {
+	const fromInfo = entityInfos.get(relationship.from);
+	const toInfo = entityInfos.get(relationship.to);
+	if (!fromInfo || !toInfo || !relationship.foreignKey) {
+		return;
+	}
+
+	const toForeignKey = resolveEntityColumnName(toInfo, relationship.foreignKey);
+	const fromForeignKey = resolveEntityColumnName(fromInfo, relationship.foreignKey);
+
+	let ownerInfo = toForeignKey ? toInfo : fromForeignKey ? fromInfo : toInfo;
+	const foreignKey =
+		ownerInfo === toInfo
+			? (toForeignKey ?? toDbName(relationship.foreignKey))
+			: (fromForeignKey ?? toDbName(relationship.foreignKey));
+
+	const referenceInfo = ownerInfo === toInfo ? fromInfo : toInfo;
+	const refPrimaryKey = toDbName(relationship.parentKey ?? referenceInfo.primaryKey ?? "");
+	if (!refPrimaryKey || !referenceInfo.primaryKey) {
+		warnings.push(`Relationship "${relationship.from}->${relationship.to}" ignored: missing parent key.`);
+		return;
+	}
+
+	const refColumn = findColumn(referenceInfo.table, refPrimaryKey);
+	if (!refColumn) {
+		warnings.push(
+			`Relationship "${relationship.from}->${relationship.to}" ignored: parent key column "${refPrimaryKey}" not found.`,
+		);
+		return;
+	}
+
+	if (!ownerInfo.columns.has(foreignKey)) {
+		ensureColumn(ownerInfo, cloneColumn(refColumn, foreignKey, true));
+	}
+
+	const onDelete = relationship.ownership === "parent" ? "CASCADE" : "NO ACTION";
+	const fk = {
+		name: buildObjectName("FK", ownerInfo.tableName, referenceInfo.tableName, foreignKey),
+		columns: [foreignKey],
+		referenceTable: referenceInfo.tableName,
+		referenceColumns: [refPrimaryKey],
+		onDelete,
+		onUpdate: "NO ACTION",
+	};
+	ensureForeignKey(ownerInfo.table, fk);
+
+	const relationIndexColumns = [foreignKey];
+	if (
+		ownerInfo.primaryKey &&
+		ownerInfo.primaryKey !== foreignKey &&
+		ownerInfo.columns.has(ownerInfo.primaryKey)
+	) {
+		relationIndexColumns.push(ownerInfo.primaryKey);
+	}
+	ensureIndex(ownerInfo.table, {
+		name: buildObjectName("IDX", ownerInfo.tableName, ...relationIndexColumns),
+		columns: relationIndexColumns,
+	});
+};
+
+const applyManyToManyRelationship = (relationship, entityInfos, tableInfos, tables, warnings) => {
+	const fromInfo = entityInfos.get(relationship.from);
+	const toInfo = entityInfos.get(relationship.to);
+	const through = relationship.through;
+	if (!fromInfo || !toInfo || !through) {
+		return;
+	}
+
+	const fromPk = toDbName(relationship.parentKey ?? fromInfo.primaryKey ?? "");
+	const toPk = toDbName(toInfo.primaryKey ?? "");
+	if (!fromPk || !toPk) {
+		warnings.push(`Relationship "${relationship.from}<->${relationship.to}" ignored: missing primary key.`);
+		return;
+	}
+
+	const fromPkColumn = findColumn(fromInfo.table, fromPk);
+	const toPkColumn = findColumn(toInfo.table, toPk);
+	if (!fromPkColumn || !toPkColumn) {
+		warnings.push(`Relationship "${relationship.from}<->${relationship.to}" ignored: parent/child key column not found.`);
+		return;
+	}
+
+	let throughInfo = tableInfos.get(through.table);
+	if (!throughInfo) {
+		const throughDbIndices = intersectDbIndices(fromInfo.dbIndices, toInfo.dbIndices);
+		const throughTable = {
+			name: through.table,
+			dbIndex: throughDbIndices[0],
+			columns: [
+				cloneColumn(fromPkColumn, through.fromKey, false),
+				cloneColumn(toPkColumn, through.toKey, false),
+			],
+			primaryKey: { columns: [through.fromKey, through.toKey] },
+		};
+		throughInfo = {
+			entityName: `through:${through.table}`,
+			tableName: through.table,
+			dbIndices: throughDbIndices,
+			primaryKey: undefined,
+			columns: new Set([through.fromKey, through.toKey]),
+			attributeColumns: new Map([
+				[through.fromKey, through.fromKey],
+				[through.toKey, through.toKey],
+			]),
+			table: throughTable,
+		};
+		tableInfos.set(through.table, throughInfo);
+		tables.push(throughTable);
+	} else {
+		if (!throughInfo.columns.has(through.fromKey)) {
+			ensureColumn(throughInfo, cloneColumn(fromPkColumn, through.fromKey, false));
+		}
+		if (!throughInfo.columns.has(through.toKey)) {
+			ensureColumn(throughInfo, cloneColumn(toPkColumn, through.toKey, false));
+		}
+	}
+
+	const onDelete = relationship.ownership === "parent" ? "CASCADE" : "NO ACTION";
+	ensureForeignKey(throughInfo.table, {
+		name: buildObjectName("FK", throughInfo.tableName, fromInfo.tableName, through.fromKey),
+		columns: [through.fromKey],
+		referenceTable: fromInfo.tableName,
+		referenceColumns: [fromPk],
+		onDelete,
+		onUpdate: "NO ACTION",
+	});
+	ensureForeignKey(throughInfo.table, {
+		name: buildObjectName("FK", throughInfo.tableName, toInfo.tableName, through.toKey),
+		columns: [through.toKey],
+		referenceTable: toInfo.tableName,
+		referenceColumns: [toPk],
+		onDelete,
+		onUpdate: "NO ACTION",
+	});
+
+	ensureIndex(throughInfo.table, {
+		name: buildObjectName("IDX", throughInfo.tableName, through.fromKey),
+		columns: [through.fromKey],
+	});
+	ensureIndex(throughInfo.table, {
+		name: buildObjectName("IDX", throughInfo.tableName, through.toKey),
+		columns: [through.toKey],
+	});
+};
+
+const buildDomainSchemaInternal = (domainConfigContent, defaultDbIndex) => {
+	const parsed = parseDomainConfig(domainConfigContent);
+	const model = parsed?.model ?? {};
+	const entities = model?.entities ?? {};
+	const relationships = model?.relationships ?? {};
+	const warnings = [];
+	const normalizedRelationships = {};
+
+	const entityInfos = new Map();
+	const tableInfos = new Map();
+	const tables = [];
+
+	for (const [entityName, entity] of Object.entries(entities)) {
+		const runtime = buildEntityTable(entityName, entity, defaultDbIndex);
+		entityInfos.set(entityName, runtime);
+		tableInfos.set(runtime.tableName, runtime);
+		tables.push(runtime.table);
+	}
+
+	for (const [relationshipName, relationship] of Object.entries(relationships)) {
+		const normalized = normalizeRelationship(relationshipName, relationship, entityInfos, warnings);
+		if (!normalized) {
+			continue;
+		}
+
+		normalizedRelationships[relationshipName] = normalized;
+		if (normalized.type === "many-to-many") {
+			applyManyToManyRelationship(normalized, entityInfos, tableInfos, tables, warnings);
+		} else {
+			applyDirectRelationship(normalized, entityInfos, warnings);
+		}
+	}
+
+	return {
+		schema: { tables },
+		normalizedRelationships,
+		warnings,
+	};
+};
+
+const normalizeDbNameNoTruncate = (value) => {
+	const raw = String(value ?? "").trim();
+	if (!raw) {
+		return "";
+	}
+	return raw
+		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+		.replace(/[^A-Za-z0-9_]+/g, "_")
+		.replace(/^_+|_+$/g, "")
+		.replace(/_+/g, "_")
+		.toUpperCase();
+};
+
+const toBooleanFlag = (value) => {
+	if (typeof value === "boolean") {
+		return value;
+	}
+	if (typeof value === "number") {
+		return value === 1;
+	}
+	const raw = String(value ?? "").trim().toLowerCase();
+	if (!raw) {
+		return false;
+	}
+	return raw === "1" || raw === "true" || raw === "yes";
+};
+
+const hashIdentifierBase36 = (input) => {
+	let hash = 0;
+	for (let index = 0; index < input.length; index += 1) {
+		hash = (hash << 5) - hash + input.charCodeAt(index);
+		hash |= 0;
+	}
+	return Math.abs(hash).toString(36).toUpperCase().slice(0, 6);
+};
+
+const buildEntityIndexObjectName = (...parts) => {
+	const joined = parts
+		.map((part) => normalizeDbNameNoTruncate(part))
+		.filter(Boolean)
+		.join("_");
+	if (joined.length <= 31) {
+		return joined;
+	}
+	const hash = hashIdentifierBase36(joined);
+	const keep = Math.max(1, 31 - hash.length - 1);
+	return `${joined.slice(0, keep)}_${hash}`;
+};
+
+const buildIndexDefinitionKey = (index) => {
+	const columns = (index.columns ?? []).map((column) => normalizeDbNameNoTruncate(column));
+	return [
+		columns.join("|"),
+		index.unique === true ? "U1" : "U0",
+		index.descending === true ? "D1" : "D0",
+		String(index.expression ?? "").trim().toUpperCase(),
+	].join("::");
+};
+
+const getNextIndexName = (input) => {
+	const base = buildEntityIndexObjectName("IDX", input.tableName, input.indexKey);
+	if (!input.usedNames.has(normalizeDbNameNoTruncate(base))) {
+		return base;
+	}
+	let suffix = 2;
+	while (suffix < 1000) {
+		const candidate = buildEntityIndexObjectName("IDX", input.tableName, input.indexKey, String(suffix));
+		if (!input.usedNames.has(normalizeDbNameNoTruncate(candidate))) {
+			return candidate;
+		}
+		suffix += 1;
+	}
+	return buildEntityIndexObjectName("IDX", input.tableName, input.indexKey, String(Date.now()));
+};
+
+const buildAttributeColumnMap = (entity) => {
+	const attributes = entity?.attributes && typeof entity.attributes === "object" ? entity.attributes : {};
+	return new Map(
+		Object.entries(attributes).map(([attributeName, rawAttribute]) => {
+			const attribute = rawAttribute && typeof rawAttribute === "object" ? rawAttribute : {};
+			const columnName = normalizeDbNameNoTruncate(attribute.column ?? attribute.columnName ?? attributeName);
+			return [normalizeDbNameNoTruncate(attributeName), columnName];
+		}),
+	);
+};
+
+const mergeEntityIndices = (input) => {
+	const existing = Array.isArray(input.table?.indexes) ? [...(input.table.indexes ?? [])] : [];
+	const seenByDefinition = new Set();
+	for (const idx of existing) {
+		seenByDefinition.add(buildIndexDefinitionKey(idx));
+	}
+	const usedNames = new Set(existing.map((idx) => normalizeDbNameNoTruncate(idx?.name ?? "")).filter(Boolean));
+
+	for (const [indexKey, rawIndex] of Object.entries(input.indexConfig)) {
+		const cfg = rawIndex && typeof rawIndex === "object" ? rawIndex : null;
+		if (!cfg) {
+			continue;
+		}
+		const requestedColumns = Array.isArray(cfg.columns) ? cfg.columns : [];
+		const columns = requestedColumns
+			.map((attributeName) => {
+				const normalizedAttributeName = normalizeDbNameNoTruncate(attributeName);
+				return input.attributeColumnMap.get(normalizedAttributeName) ?? "";
+			})
+			.filter(Boolean);
+		if (columns.length === 0) {
+			continue;
+		}
+		const orders = Array.isArray(cfg.orders)
+			? cfg.orders.map((order) => String(order ?? "").trim().toLowerCase())
+			: [];
+		const hasAnyDesc = orders.some((order) => order === "desc");
+		const allDesc = orders.length > 0 && orders.every((order) => order === "desc");
+		const unique = toBooleanFlag(cfg.unique);
+		const nextIndex = {
+			name: getNextIndexName({ tableName: input.table.name, indexKey, usedNames }),
+			columns,
+			unique,
+			...(hasAnyDesc && allDesc ? { descending: true } : {}),
+		};
+		const definitionKey = buildIndexDefinitionKey(nextIndex);
+		if (seenByDefinition.has(definitionKey)) {
+			continue;
+		}
+		seenByDefinition.add(definitionKey);
+		usedNames.add(normalizeDbNameNoTruncate(nextIndex.name));
+		existing.push(nextIndex);
+	}
+
+	return existing;
+};
+
+const parseDomainConfigContent = (content) => {
+	const raw = String(content ?? "").trim();
+	if (!raw) {
+		return {};
+	}
+
+	try {
+		return JSON.parse(raw);
+	} catch {}
+
+	try {
+		const evaluator = new Function(
+			`
+			let get;
+			${raw}
+			if (typeof get === 'function') {
+				return get();
+			}
+			return {};
+		`,
+		);
+		return evaluator();
+	} catch {
+		return {};
+	}
+};
+
+const enrichSchemaWithEntityIndices = (schema, domainConfigContent) => {
+	const parsed = parseDomainConfigContent(domainConfigContent);
+	const entities = parsed && typeof parsed === "object" ? parsed?.model?.entities : null;
+	if (!entities || typeof entities !== "object") {
+		return;
+	}
+
+	const tablesByName = new Map();
+	for (const table of schema?.tables ?? []) {
+		const normalizedName = normalizeDbNameNoTruncate(table?.name ?? "");
+		if (normalizedName) {
+			tablesByName.set(normalizedName, table);
+		}
+	}
+
+	for (const [entityName, rawEntity] of Object.entries(entities)) {
+		const entity = rawEntity && typeof rawEntity === "object" ? rawEntity : null;
+		if (!entity) {
+			continue;
+		}
+		const tableName = normalizeDbNameNoTruncate(entity.table ?? entity.tableName ?? entityName);
+		if (!tableName) {
+			continue;
+		}
+		const table = tablesByName.get(tableName);
+		if (!table) {
+			continue;
+		}
+		const attributeColumnMap = buildAttributeColumnMap(entity);
+		const indexConfig = entity.indices && typeof entity.indices === "object" ? entity.indices : null;
+		if (!indexConfig) {
+			continue;
+		}
+		table.indexes = mergeEntityIndices({ table, indexConfig, attributeColumnMap });
+	}
+};
+
+const resolveDsBaseConfig = (config = {}) => {
+	const globalConfig = getGlobalConfig() || {};
+	const isSecure = config.secure ?? globalConfig.secure ?? false;
+	const protocol = isSecure ? "https://" : "http://";
+	const hostname = config.hostname ?? globalConfig.hostname ?? "127.0.0.1";
+	const port = config.port ?? globalConfig.port ?? 212;
+	return {
+		url: config.url || `${protocol}${hostname}:${port}`,
+		dbindex: config.dbindex ?? config.dbIndex ?? globalConfig.dbindex ?? 2,
+		timeout: config.timeout ?? IDLE_SOCKET_TIMEOUT_MILLISECONDS,
+	};
+};
+
+const resolveExecutionDbIndex = (dbIndex, config) => {
+	const explicitDbIndex = Number(dbIndex);
+	if (Number.isInteger(explicitDbIndex) && explicitDbIndex > 0) {
+		return explicitDbIndex;
+	}
+
+	const defaultDbIndex = Number(resolveDsBaseConfig(config).dbindex);
+	return Number.isInteger(defaultDbIndex) && defaultDbIndex > 0 ? defaultDbIndex : 1;
+};
+
+const extractFinaHttpErrorMessage = (error, sql) => {
+	const responseData = error?.response?.data;
+	let parsedBody = responseData;
+	if (typeof responseData === "string") {
+		try {
+			parsedBody = JSON.parse(responseData);
+		} catch {
+			parsedBody = responseData;
+		}
+	}
+
+	const serverMessage =
+		(parsedBody && typeof parsedBody === "object" && (parsedBody.error || parsedBody.message)) ||
+		(typeof parsedBody === "string" && parsedBody) ||
+		null;
+
+	const status = error?.response?.status;
+	const statusPart = status ? `HTTP ${status}` : error?.message || "request failed";
+	const messagePart = serverMessage ? `: ${serverMessage}` : "";
+	return `ExecuteSQL ${statusPart}${messagePart} (sql: ${String(sql).slice(0, 200)})`;
+};
+
+const runFinaExecuteSql = async (sql, dbIndex, config) => {
+	const cfg = resolveDsBaseConfig(config);
+	const resolvedDbIndex = Number.isInteger(dbIndex) && dbIndex > 0 ? dbIndex : cfg.dbindex;
+	const url = `${cfg.url}/fina/rest/${FINA_METHOD_CLASS}/%22ExecuteSQL%22`;
+	const body = JSON.stringify({ _parameters: [sql, String(resolvedDbIndex)] });
+
+	let res;
+	try {
+		res = await axios.request({
+			method: "POST",
+			url,
+			data: body,
+			timeout: cfg.timeout,
+			headers: { "content-type": "text/plain" },
+		});
+	} catch (error) {
+		throw new Error(extractFinaHttpErrorMessage(error, sql));
+	}
+
+	const parsedRes = typeof res.data === "string" ? JSON.parse(res.data) : res.data;
+	if (parsedRes && parsedRes.error) {
+		throw new Error(parsedRes.error);
+	}
+
+	if (parsedRes && Array.isArray(parsedRes.result) && parsedRes.result.length > 0) {
+		if (parsedRes.result[0] && parsedRes.result[0].error) {
+			throw new Error(parsedRes.result[0].error);
+		}
+
+		try {
+			const parsed = JSON.parse(parsedRes.result[0]);
+			const rows = Array.isArray(parsed?.data) ? parsed.data : [];
+			return rows.map((row) =>
+				Object.keys(row).reduce((acc, key) => {
+					acc[key.toLowerCase()] = row[key];
+					return acc;
+				}, {}),
+			);
+		} catch {
+			return [];
+		}
+	}
+
+	return [];
+};
+
+const execRawSql = async (sql, dbIndex, config) => {
+	return runFinaExecuteSql(sanitizeSql(sql), resolveExecutionDbIndex(dbIndex, config), config);
+};
+
+const loadTableExists = async (tableName, dbIndex, config) => {
+	const queries = buildTableStructureQueries(tableName);
+	const rows = await execRawSql(queries.tableExistsSql, dbIndex, config);
+	return Number(rows?.[0]?.["TABLE_EXISTS"] ?? rows?.[0]?.["table_exists"] ?? 0) === 1;
+};
+
+const loadTableSnapshot = async (tableName, knownExists, dbIndex, config) => {
+	const queries = buildTableStructureQueries(tableName);
+	const tableExistsRows =
+		knownExists == null
+			? await execRawSql(queries.tableExistsSql, dbIndex, config)
+			: [{ TABLE_EXISTS: knownExists ? 1 : 0 }];
+
+	const [columnRows, primaryKeyRows, uniqueKeyRows, checkConstraintRows, indexRows, foreignKeyRows, incomingForeignKeyRows, columnDependencyRows] =
+		await Promise.all([
+			execRawSql(queries.columnsSql, dbIndex, config),
+			execRawSql(queries.primaryKeySql, dbIndex, config),
+			execRawSql(queries.uniqueKeysSql, dbIndex, config),
+			execRawSql(queries.checkConstraintsSql, dbIndex, config),
+			execRawSql(queries.indexesSql, dbIndex, config),
+			execRawSql(queries.foreignKeysSql, dbIndex, config),
+			execRawSql(queries.incomingForeignKeysSql, dbIndex, config),
+			execRawSql(queries.columnDependenciesSql, dbIndex, config),
+		]);
+
+	return buildStructureSnapshotFromRows({
+		tableName,
+		tableExistsRows,
+		columnRows,
+		primaryKeyRows,
+		uniqueKeyRows,
+		checkConstraintRows,
+		indexRows,
+		foreignKeyRows,
+		incomingForeignKeyRows,
+		columnDependencyRows,
+	});
+};
+
+const loadGeneratorSyncPlan = async (table, dbIndex, config) => {
+	if (!shouldSyncGenerator(table)) {
+		return { statements: [], differences: [] };
+	}
+
+	const queries = buildGeneratorStructureQueries(table);
+	const [generatorRows, triggerRows] = await Promise.all([
+		execRawSql(queries.generatorExistsSql, dbIndex, config),
+		execRawSql(queries.triggerSql, dbIndex, config),
+	]);
+
+	return buildGeneratorSyncPlan(table, generatorRows, triggerRows);
+};
+
+const toFirebird25CompatibleDdl = (statement) => {
+	const sanitizedStatement = sanitizeSql(statement);
+	const notNullMatch = sanitizedStatement.match(
+		/^ALTER\s+TABLE\s+("[^"]+"|[A-Z0-9_$]+)\s+ALTER\s+(?:COLUMN\s+)?("[^"]+"|[A-Z0-9_$]+)\s+SET\s+NOT\s+NULL;?$/i,
+	);
+	if (!notNullMatch) {
+		return sanitizedStatement;
+	}
+
+	const tableIdentifier = notNullMatch[1];
+	const columnIdentifier = notNullMatch[2];
+	const constraintName = buildFirebird25NotNullCheckName(tableIdentifier, columnIdentifier);
+	return `ALTER TABLE ${tableIdentifier} ADD CONSTRAINT ${constraintName} CHECK (${columnIdentifier} IS NOT NULL)`;
+};
+
+const executeStatementsBySql = async (statements, dbIndex, config, ctx) => {
+	if (statements.length === 0) {
+		return null;
+	}
+
+	for (const statement of statements) {
+		const signature = toSimpleHash(statement);
+		if (ctx?.executedBlockSignatures?.has(signature)) {
+			continue;
+		}
+		let lastError;
+		let succeeded = false;
+		for (let attempt = 0; attempt < 3; attempt++) {
+			try {
+				await execRawSql(statement, dbIndex, config);
+				succeeded = true;
+				break;
+			} catch (error) {
+				lastError = error;
+			}
+		}
+		if (!succeeded) {
+			throw lastError;
+		}
+		ctx?.executedBlockSignatures?.add(signature);
+	}
+	return null;
+};
+
+const executeSqlStatements = async (statements, dbIndex, config, ctx) => {
+	const normalizedStatements = (statements ?? [])
+		.map((statement) => toFirebird25CompatibleDdl(statement))
+		.map((statement) => sanitizeSql(statement))
+		.filter((statement) => statement.length > 0);
+	if (normalizedStatements.length === 0) {
+		return null;
+	}
+
+	// Every DDL statement (CREATE TABLE, CREATE GENERATOR, CREATE TRIGGER, ALTER TABLE, ...) is
+	// submitted one at a time via the FINA ExecuteSQL endpoint, never batched via EXECUTE STATEMENT
+	// wrapped inside an EXECUTE BLOCK -- Firebird does not correctly resolve NEW/OLD trigger
+	// pseudo-columns when a CREATE TRIGGER body is compiled that way.
+	await executeStatementsBySql(normalizedStatements, dbIndex, config, ctx);
+	return null;
+};
+
+const logGeneratorCreateStatements = (tableName, statements) => {
+	if (statements.some((statement) => /^\s*CREATE\s+GENERATOR\b/i.test(statement))) {
+		console.log(`[AppConfig Publish] Table ${tableName} generator not found. Creating...`);
+	}
+};
+
+const logTriggerCreateStatements = (tableName, statements) => {
+	for (const statement of statements) {
+		const match = statement.match(/^\s*CREATE\s+TRIGGER\s+([A-Z0-9_$"]+)/i);
+		if (match) {
+			const triggerName = String(match[1] ?? "").replace(/"/g, "").trim();
+			if (triggerName) {
+				console.log(`[AppConfig Publish] Table ${tableName} trigger ${triggerName} not found. Creating...`);
+			}
+		}
+	}
+};
+
+const logIndexCreateStatements = (tableName, statements) => {
+	for (const statement of statements) {
+		const match = statement.match(/^\s*CREATE\s+(?:UNIQUE\s+|DESC\s+|UNIQUE\s+DESC\s+)?INDEX\s+([A-Z0-9_$"]+)/i);
+		if (match) {
+			const indexName = String(match[1] ?? "").replace(/"/g, "").trim();
+			if (indexName) {
+				console.log(`[AppConfig Publish] Table ${tableName} index ${indexName} not found. Creating...`);
+			}
+		}
+	}
+};
+
+const appendDryRunReport = (report, migrationMode, tableName, phase, data) => {
+	const warnings = data.warnings ?? [];
+	const differences = data.differences ?? [];
+	const blockedActions = warnings.filter((warning) => /safe mode|requires manual/i.test(String(warning)));
+	report.push({
+		tableName,
+		phase,
+		migrationMode,
+		statements: data.statements ?? [],
+		warnings,
+		differences,
+		blockedActions,
+	});
+};
+
+const applyGeneratorSyncPlan = async (table, generatorSyncPlan, dbIndex, config, ctx) => {
+	if (generatorSyncPlan.differences.length > 0) {
+		console.log(`[AppConfig Publish] Table ${table.name} generator discrepancies:`, generatorSyncPlan.differences);
+	}
+	appendDryRunReport(ctx.report, ctx.migrationMode, table.name, "generator-sync", {
+		statements: generatorSyncPlan.statements,
+		warnings: [],
+		differences: generatorSyncPlan.differences,
+	});
+	if (generatorSyncPlan.statements.length === 0) {
+		if (generatorSyncPlan.differences.length > 0) {
+			throw new Error(
+				`[AppConfig Publish] Table ${table.name} unresolved generator/trigger discrepancies: ${generatorSyncPlan.differences.join(" | ")}`,
+			);
+		}
+		return null;
+	}
+	logGeneratorCreateStatements(table.name, generatorSyncPlan.statements);
+	logTriggerCreateStatements(table.name, generatorSyncPlan.statements);
+
+	await executeSqlStatements(generatorSyncPlan.statements, dbIndex, config, ctx);
+	return null;
+};
+
+const splitSqlStatements = (sqlBatch) => {
+	const source = sqlBatch ?? "";
+	const statements = [];
+	let current = "";
+	let quote = "";
+	let escaped = false;
+
+	for (let i = 0; i < source.length; i++) {
+		const ch = source[i];
+		current += ch;
+
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (quote === "'" && ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === quote) {
+				quote = "";
+			}
+			continue;
+		}
+
+		if (ch === '"' || ch === "'") {
+			quote = ch;
+			continue;
+		}
+
+		if (ch === ";") {
+			const statement = current.trim();
+			if (statement.length > 0) {
+				statements.push(statement);
+			}
+			current = "";
+		}
+	}
+
+	const tail = current.trim();
+	if (tail.length > 0) {
+		statements.push(tail);
+	}
+
+	return statements.map((statement) => sanitizeSql(statement));
+};
+
+const syncTable = async (table, ctx) => {
+	const tableDbIndex = resolveExecutionDbIndex(table?.dbIndex, ctx.config);
+	const exists = await loadTableExists(table.name, tableDbIndex, ctx.config);
+
+	if (!exists) {
+		console.log(`[AppConfig Publish] Table ${table.name} not found. Creating...`);
+		const createSqlBatch = generateCreateSchemaSql({ tables: [table] }, false);
+		const createStatements = splitSqlStatements(createSqlBatch);
+		appendDryRunReport(ctx.report, ctx.migrationMode, table.name, "create-missing-table", {
+			statements: createStatements,
+			warnings: [],
+			differences: [`Table "${table.name}" does not exist.`],
+		});
+		await executeSqlStatements(createStatements, tableDbIndex, ctx.config, ctx);
+
+		const generatorSyncPlan = await loadGeneratorSyncPlan(table, tableDbIndex, ctx.config);
+		await applyGeneratorSyncPlan(table, generatorSyncPlan, tableDbIndex, ctx.config, ctx);
+
+		const latestSnapshot = await loadTableSnapshot(table.name, true, tableDbIndex, ctx.config);
+		const postCreateSyncPlan = buildTableSyncPlan(table, latestSnapshot, { migrationMode: ctx.migrationMode });
+		if (postCreateSyncPlan.warnings.length > 0) {
+			console.log(`[AppConfig Publish] Table ${table.name} post-create warnings:`, postCreateSyncPlan.warnings);
+		}
+		appendDryRunReport(ctx.report, ctx.migrationMode, table.name, "post-create-sync", postCreateSyncPlan);
+		if (postCreateSyncPlan.statements.length === 0) {
+			return null;
+		}
+
+		console.log(`[AppConfig Publish] Table ${table.name} post-create discrepancies:`, postCreateSyncPlan.differences);
+		logIndexCreateStatements(table.name, postCreateSyncPlan.statements);
+		return executeSqlStatements(postCreateSyncPlan.statements, tableDbIndex, ctx.config, ctx);
+	}
+
+	const snapshot = await loadTableSnapshot(table.name, true, tableDbIndex, ctx.config);
+	const compareResult = compareTableStructure(table, snapshot);
+	const generatorSyncPlan = await loadGeneratorSyncPlan(table, tableDbIndex, ctx.config);
+	await applyGeneratorSyncPlan(table, generatorSyncPlan, tableDbIndex, ctx.config, ctx);
+
+	if (compareResult.isSame) {
+		return null;
+	}
+
+	console.log(`[AppConfig Publish] Table ${table.name} discrepancies:`, compareResult.differences);
+	const syncPlan = buildTableSyncPlan(table, snapshot, { migrationMode: ctx.migrationMode });
+	if (syncPlan.warnings.length > 0) {
+		console.log(`[AppConfig Publish] Table ${table.name} sync warnings:`, syncPlan.warnings);
+	}
+	appendDryRunReport(ctx.report, ctx.migrationMode, table.name, "sync-existing-table", syncPlan);
+	if (syncPlan.statements.length === 0) {
+		return null;
+	}
+	logIndexCreateStatements(table.name, syncPlan.statements);
+
+	return executeSqlStatements(syncPlan.statements, tableDbIndex, ctx.config, ctx);
+};
+
+const resolveConfigFromPayload = (payload = {}, argv = {}) => {
+	const resolvedDbIndex = toNonNegativeInteger(payload.dbIndex) ?? toNonNegativeInteger(argv.dbindex) ?? 2;
+	return {
+		dbindex: resolvedDbIndex,
+		dbIndex: resolvedDbIndex,
+		...(payload.url ? { url: payload.url } : {}),
+		...(payload.hostname ? { hostname: payload.hostname } : {}),
+		...(payload.port ? { port: payload.port } : {}),
+		...(payload.secure != null ? { secure: payload.secure } : {}),
+		...(payload.subdomain || argv.subdomain ? { subdomain: payload.subdomain ?? argv.subdomain } : {}),
+		...(payload.timeout ? { timeout: payload.timeout } : {}),
+	};
+};
+
+const buildPublishStatusConfigKey = (domainName, domainVersion) => ({
+	name: `${domainName}__PUBLISH_STATUS`,
+	version: domainVersion,
+});
+
+const writePublishStatus = async (name, version, statusPayload, config) => {
+	const upsertSql = getUpsertBlock(name, version, JSON.stringify(statusPayload));
+	await executeBlock(upsertSql, config);
+};
+
+export const getPublishStatus = async (payload = {}, argv = {}) => {
+	const domainName = String(payload?.domainName ?? "").trim();
+	const domainVersion = String(payload?.domainVersion ?? "").trim();
+	if (!domainName || !domainVersion) {
+		return { status: "UNKNOWN", error: "payload.domainName and payload.domainVersion are required." };
+	}
+
+	const config = resolveConfigFromPayload(payload, argv);
+	const { name, version } = buildPublishStatusConfigKey(domainName, domainVersion);
+	const rows = await queryData(getConfigByNameVersionParameters(name, version), config);
+	const row = rows?.[0];
+	if (!row?.data) {
+		return { status: "NOT_STARTED" };
+	}
+
+	try {
+		return JSON.parse(String(row.data));
+	} catch {
+		return { status: "UNKNOWN" };
+	}
+};
+
+export const publishConfigsAsync = async (payload = {}, argv = {}) => {
+	const domainName = String(payload?.domainName ?? "").trim();
+	const domainVersion = String(payload?.domainVersion ?? "").trim();
+	if (!domainName) {
+		return { success: false, error: "payload.domainName is required." };
+	}
+	if (!domainVersion) {
+		return { success: false, error: "payload.domainVersion is required." };
+	}
+
+	const config = resolveConfigFromPayload(payload, argv);
+	const { name, version } = buildPublishStatusConfigKey(domainName, domainVersion);
+	const startedAt = new Date().toISOString();
+
+	await writePublishStatus(name, version, { status: "IN_PROGRESS", domainName, domainVersion, startedAt }, config);
+
+	publishConfigs(payload, argv)
+		.then((result) => {
+			const { report, ...resultWithoutReport } = result ?? {};
+			return writePublishStatus(
+				name,
+				version,
+				{
+					...resultWithoutReport,
+					status: result?.success ? "SUCCESS" : "FAILED",
+					domainName,
+					domainVersion,
+					startedAt,
+					finishedAt: new Date().toISOString(),
+				},
+				config,
+			);
+		})
+		.catch((error) =>
+			writePublishStatus(
+				name,
+				version,
+				{
+					success: false,
+					status: "FAILED",
+					domainName,
+					domainVersion,
+					startedAt,
+					finishedAt: new Date().toISOString(),
+					error: error?.message ?? String(error),
+				},
+				config,
+			),
+		)
+		.catch((error) => {
+			console.error(`[AppConfig Publish] Failed to record publish status for ${domainName}@${domainVersion}:`, error);
+		});
+
+	return { success: true, status: "IN_PROGRESS", domainName, domainVersion, startedAt };
+};
+
+export const publishConfigs = async (payload = {}, argv = {}) => {
+	try {
+		const domainName = payload.domainName;
+		const domainVersion = payload.domainVersion;
+		if (!domainName) {
+			throw new Error("payload.domainName is required.");
+		}
+		if (!domainVersion) {
+			throw new Error("payload.domainVersion is required.");
+		}
+
+		const migrationMode = payload.migrationMode === "aggressive" ? "aggressive" : "safe";
+		const config = resolveConfigFromPayload(payload, argv);
+
+		const configRows = await queryData(getConfigByNameVersionParameters(domainName, domainVersion), config);
+		const domainRecord = configRows?.[0];
+		if (!domainRecord?.data) {
+			throw new Error(`SYS$CONFIG record ${domainName}@${domainVersion} was not found.`);
+		}
+
+		const domainConfigContent = String(domainRecord.data);
+
+		const preview = buildDomainDdlPreview(domainConfigContent, config.dbIndex);
+		enrichSchemaWithEntityIndices(preview.schema, domainConfigContent);
+		if (preview.warnings.length > 0) {
+			throw new Error(`Domain model warning (${domainName}): ${preview.warnings.join(" | ")}`);
+		}
+
+		const report = [];
+		if (preview.schema.tables.length === 0) {
+			return { success: true, domainName, domainVersion, tablesProcessed: 0, report };
+		}
+
+		const orderedTables = orderTablesByDependency(preview.schema.tables);
+		const ctx = {
+			config,
+			migrationMode,
+			executedBlockSignatures: new Set(),
+			report,
+		};
+
+		for (const table of orderedTables) {
+			await syncTable(table, ctx);
+		}
+
+		if (report.length > 0) {
+			console.log(`[AppConfig Publish] Publish report (${domainName}@${domainVersion}):`, report);
+		}
+
+		return {
+			success: true,
+			domainName,
+			domainVersion,
+			tablesProcessed: orderedTables.length,
+			report,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error?.message || error,
+		};
+	}
+};