@roomwise/calc-engine 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1610 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _jsep_plugin_ternary = require("@jsep-plugin/ternary");
+_jsep_plugin_ternary = __toESM(_jsep_plugin_ternary, 1);
+let jsep = require("jsep");
+jsep = __toESM(jsep, 1);
+let zod = require("zod");
+//#region src/money/convert-uah.ts
+const RATE_PATTERN = /^(\d+)(?:\.(\d{1,4}))?$/;
+const RATE_SCALE = 10000n;
+function scaleRate(rate) {
+	const match = RATE_PATTERN.exec(String(rate));
+	if (!match) throw new RangeError(`Invalid exchange rate: ${rate}`);
+	const scaled = BigInt(match[1]) * RATE_SCALE + BigInt((match[2] ?? "").padEnd(4, "0"));
+	if (scaled <= 0n) throw new RangeError(`Invalid exchange rate: ${rate}`);
+	return scaled;
+}
+function convertCentsToKopecks(cents, rate) {
+	if (!Number.isSafeInteger(cents) || cents < 0) throw new RangeError(`Invalid cents amount: ${cents}`);
+	const kopecks = (BigInt(cents) * scaleRate(rate) + RATE_SCALE / 2n) / RATE_SCALE;
+	if (kopecks > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError(`Amount exceeds the safe integer range: ${cents}`);
+	return Number(kopecks);
+}
+//#endregion
+//#region src/money/to-cents.ts
+function toCents(dollars) {
+	if (!Number.isFinite(dollars) || dollars < 0) throw new RangeError(`Invalid dollar amount: ${dollars}`);
+	const cents = Math.round(Number((dollars * 100).toPrecision(15)));
+	if (!Number.isSafeInteger(cents)) throw new RangeError(`Amount exceeds the safe integer range: ${dollars}`);
+	return cents;
+}
+//#endregion
+//#region src/estimate/line.ts
+const MAX_LINE_CENTS = 1e10;
+function createLine(init) {
+	return {
+		status: "OK",
+		roomClientId: null,
+		categoryId: null,
+		productId: null,
+		optionId: null,
+		packageItemId: null,
+		ruleId: null,
+		quantity: null,
+		unit: null,
+		unitPriceCents: null,
+		amountCents: 0,
+		amountUahKopecks: null,
+		warnings: [],
+		error: null,
+		...init
+	};
+}
+function failedLine(init, status, error) {
+	return createLine({
+		...init,
+		status,
+		error
+	});
+}
+function pricedLine(init, dollars) {
+	if (!Number.isFinite(dollars) || dollars < 0 || dollars * 100 > 1e10) return failedLine(init, "ERROR", {
+		code: "AMOUNT_OUT_OF_RANGE",
+		params: { maxCents: MAX_LINE_CENTS }
+	});
+	return createLine({
+		...init,
+		amountCents: toCents(dollars)
+	});
+}
+function roundQuantity(quantity) {
+	return Math.round(quantity * 1e3) / 1e3;
+}
+//#endregion
+//#region src/estimate/line-id.ts
+function lineId(section, ...parts) {
+	return [section, ...parts].join(":");
+}
+//#endregion
+//#region src/estimate/option-line.ts
+function unitQuantity(unit, rooms, pieces) {
+	switch (unit) {
+		case "PIECE": return pieces;
+		case "PROJECT": return 1;
+		case "ROOM": return rooms.length;
+		case "ROOM_SQM": return rooms.reduce((sum, room) => sum + room.lengthM * room.widthM, 0);
+	}
+}
+function optionLine(configuration, option, selection) {
+	const init = {
+		id: lineId(option.kind, "option", option.id),
+		section: option.kind,
+		optionId: option.id
+	};
+	if (!option.available) return failedLine(init, "UNAVAILABLE", {
+		code: "PRODUCT_UNAVAILABLE",
+		params: { optionId: option.id }
+	});
+	const selected = configuration.rooms.filter((room) => selection.roomClientIds?.includes(room.clientId));
+	const allowed = selected.filter((room) => option.roomTypeCodes.includes(room.roomTypeCode));
+	const rejected = selected.filter((room) => !allowed.includes(room));
+	const quantity = unitQuantity(option.unit, allowed, selection.quantity ?? option.minQuantity ?? 1);
+	return pricedLine({
+		...init,
+		quantity: roundQuantity(quantity),
+		unit: option.unit,
+		unitPriceCents: option.priceCents,
+		warnings: rejected.map((room) => ({
+			code: "OPTION_ROOM_TYPE_NOT_ALLOWED",
+			params: {
+				roomClientId: room.clientId,
+				roomTypeCode: room.roomTypeCode
+			}
+		}))
+	}, option.priceCents / 100 * quantity);
+}
+function optionLines(configuration, data, kind) {
+	return configuration.options.flatMap((selection) => {
+		const option = data.options.find((item) => item.id === selection.optionId);
+		return option?.kind === kind ? [optionLine(configuration, option, selection)] : [];
+	});
+}
+//#endregion
+//#region src/estimate/additional.ts
+function additionalLines(configuration, data) {
+	return optionLines(configuration, data, "ADDITIONAL");
+}
+//#endregion
+//#region src/estimate/base.ts
+function baseLine(configuration, data) {
+	const init = {
+		id: lineId("BASE"),
+		section: "BASE"
+	};
+	const area = configuration.totalAreaSqm;
+	const rate = data.baseRates.find((candidate) => candidate.finishLevel === configuration.finishLevel && candidate.areaFromSqm <= area && area < candidate.areaToSqm);
+	if (rate === void 0) return failedLine(init, "NOT_CALCULATED", {
+		code: "BASE_RATE_NOT_FOUND",
+		params: {
+			totalAreaSqm: area,
+			finishLevel: configuration.finishLevel
+		}
+	});
+	return pricedLine({
+		...init,
+		quantity: roundQuantity(area),
+		unit: "SQM",
+		unitPriceCents: rate.rateCentsPerSqm
+	}, rate.rateCentsPerSqm / 100 * area);
+}
+//#endregion
+//#region src/estimate/engineering.ts
+function packageLine(configuration, item) {
+	const init = {
+		id: lineId("ENGINEERING", "package", item.id),
+		section: "ENGINEERING",
+		packageItemId: item.id
+	};
+	if (item.includedInBase) return createLine({
+		...init,
+		status: "INCLUDED"
+	});
+	if (item.priceCents === null || item.unit === null) return failedLine(init, "NOT_CALCULATED", {
+		code: "PACKAGE_ITEM_PRICE_MISSING",
+		params: { packageItemId: item.id }
+	});
+	const quantity = unitQuantity(item.unit, configuration.rooms, 1);
+	return pricedLine({
+		...init,
+		quantity: roundQuantity(quantity),
+		unit: item.unit,
+		unitPriceCents: item.priceCents
+	}, item.priceCents / 100 * quantity);
+}
+function engineeringLines(configuration, data) {
+	return [...data.packageItems.map((item) => packageLine(configuration, item)), ...optionLines(configuration, data, "ENGINEERING")];
+}
+//#endregion
+//#region src/variables/object.ts
+const COUNTED_AS_ROOMS = [
+	"LIVING_ROOM",
+	"BEDROOM",
+	"KITCHEN_LIVING"
+];
+function objectVariables(configuration) {
+	return {
+		totalArea: configuration.totalAreaSqm,
+		balconyArea: configuration.balconyAreaSqm,
+		balconyTiles: configuration.balconyTiles,
+		gas: configuration.gas,
+		kitchenType: configuration.kitchenType,
+		finishLevel: configuration.finishLevel,
+		roomsCount: configuration.rooms.filter((room) => COUNTED_AS_ROOMS.includes(room.roomTypeCode)).length,
+		bathroomsCount: configuration.rooms.filter((room) => room.roomTypeCode === "BATHROOM").length
+	};
+}
+//#endregion
+//#region src/variables/product.ts
+function productVariablesOf(product, wastePercent) {
+	return {
+		price: product.priceCents / 100,
+		waste: wastePercent / 100,
+		unit: product.unit
+	};
+}
+function productVariables(product, category) {
+	return productVariablesOf(product, product.wastePercentOverride ?? category.wastePercent);
+}
+//#endregion
+//#region src/variables/room.ts
+function roomVariables(room) {
+	const perimeter = 2 * (room.lengthM + room.widthM);
+	return {
+		length: room.lengthM,
+		width: room.widthM,
+		height: room.heightM,
+		floorArea: room.lengthM * room.widthM,
+		perimeter,
+		wallArea: perimeter * room.heightM,
+		heatedFloor: room.heatedFloor,
+		roomType: room.roomTypeCode
+	};
+}
+//#endregion
+//#region src/formula/language.ts
+const COEFFICIENT_NAMESPACE = "coef";
+const FORMULA_FUNCTION_TABLE = new Map([
+	{
+		name: "min",
+		minArgs: 1,
+		maxArgs: Number.POSITIVE_INFINITY,
+		apply: (args) => Math.min(...args)
+	},
+	{
+		name: "max",
+		minArgs: 1,
+		maxArgs: Number.POSITIVE_INFINITY,
+		apply: (args) => Math.max(...args)
+	},
+	{
+		name: "round",
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => Math.round(args[0])
+	},
+	{
+		name: "ceil",
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => Math.ceil(args[0])
+	},
+	{
+		name: "floor",
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => Math.floor(args[0])
+	}
+].map((fn) => [fn.name, fn]));
+const FORMULA_FUNCTIONS = [...FORMULA_FUNCTION_TABLE.keys()];
+//#endregion
+//#region src/formula/evaluate.ts
+var EvaluationFailure = class {
+	error;
+	constructor(error) {
+		this.error = error;
+	}
+};
+function fail(node, code, params) {
+	throw new EvaluationFailure({
+		code,
+		position: node.start,
+		length: node.end - node.start,
+		...params === void 0 ? {} : { params }
+	});
+}
+function runtimeFail(node, reason, params) {
+	return fail(node, "FORMULA_RUNTIME_ERROR", {
+		...params,
+		reason
+	});
+}
+function mismatch(node, expected) {
+	return runtimeFail(node, "TYPE_MISMATCH", { expected });
+}
+function finite(node, value) {
+	return Number.isFinite(value) ? value : runtimeFail(node, "NOT_FINITE");
+}
+function asNumber(node, value) {
+	return typeof value === "number" ? value : mismatch(node, "number");
+}
+function asBoolean(node, value) {
+	return typeof value === "boolean" ? value : mismatch(node, "boolean");
+}
+function lookupVariable(node, scope) {
+	if (!Object.hasOwn(scope.variables, node.name)) return fail(node, "UNKNOWN_VARIABLE", { name: node.name });
+	return scope.variables[node.name];
+}
+function evaluateMember(node, scope) {
+	if (node.object.type !== "Identifier" || node.object.name !== "coef") return fail(node, "UNKNOWN_VARIABLE");
+	const key = node.property.name;
+	if (!Object.hasOwn(scope.coefficients, key)) return fail(node, "UNKNOWN_COEFFICIENT", { key });
+	return scope.coefficients[key];
+}
+function evaluateCall(node, scope) {
+	const spec = node.callee.type === "Identifier" ? FORMULA_FUNCTION_TABLE.get(node.callee.name) : void 0;
+	if (spec === void 0) return fail(node.callee, "UNKNOWN_FUNCTION");
+	if (node.args.length < spec.minArgs || node.args.length > spec.maxArgs) return mismatch(node, "argument count");
+	const args = node.args.map((arg) => asNumber(arg, walk(arg, scope)));
+	return finite(node, spec.apply(args));
+}
+function evaluateEquality(node, scope) {
+	const { left, right } = node;
+	const literal = [left, right].find((side) => side.type === "Literal" && typeof side.value === "string") ?? null;
+	if (literal !== null) {
+		const other = literal === left ? right : left;
+		const variable = other.type === "Identifier" ? lookupVariable(other, scope) : void 0;
+		if (typeof variable !== "string") return mismatch(other, "enum variable");
+		return node.operator === "==" ? variable === literal.value : variable !== literal.value;
+	}
+	const leftValue = walk(left, scope);
+	const rightValue = walk(right, scope);
+	if (typeof leftValue !== typeof rightValue) return mismatch(right, typeof leftValue);
+	return node.operator === "==" ? leftValue === rightValue : leftValue !== rightValue;
+}
+function evaluateBinary(node, scope) {
+	const { operator, left, right } = node;
+	if (operator === "==" || operator === "!=") return evaluateEquality(node, scope);
+	if (operator === "&&" || operator === "||") {
+		const leftValue = asBoolean(left, walk(left, scope));
+		if (operator === "&&" ? !leftValue : leftValue) return leftValue;
+		return asBoolean(right, walk(right, scope));
+	}
+	const a = asNumber(left, walk(left, scope));
+	const b = asNumber(right, walk(right, scope));
+	switch (operator) {
+		case "<": return a < b;
+		case ">": return a > b;
+		case "<=": return a <= b;
+		case ">=": return a >= b;
+		case "+": return finite(node, a + b);
+		case "-": return finite(node, a - b);
+		case "*": return finite(node, a * b);
+		case "/": return b === 0 ? runtimeFail(node, "DIVISION_BY_ZERO") : finite(node, a / b);
+	}
+}
+function walk(node, scope) {
+	switch (node.type) {
+		case "Literal": return typeof node.value === "string" ? mismatch(node, "number or boolean") : node.value;
+		case "Identifier": return lookupVariable(node, scope);
+		case "Member": return evaluateMember(node, scope);
+		case "Call": return evaluateCall(node, scope);
+		case "Unary": {
+			const argument = walk(node.argument, scope);
+			return node.operator === "!" ? !asBoolean(node.argument, argument) : finite(node, -asNumber(node.argument, argument));
+		}
+		case "Binary": return evaluateBinary(node, scope);
+		case "Conditional": return asBoolean(node.test, walk(node.test, scope)) ? walk(node.consequent, scope) : walk(node.alternate, scope);
+		default: return runtimeFail(node, "TYPE_MISMATCH", { expected: "known node" });
+	}
+}
+function evaluate(ast, scope) {
+	try {
+		return {
+			ok: true,
+			value: walk(ast, scope)
+		};
+	} catch (error) {
+		if (error instanceof EvaluationFailure) return {
+			ok: false,
+			error: error.error
+		};
+		throw error;
+	}
+}
+//#endregion
+//#region src/formula/grammar.ts
+const SEMICOLON_CODE = 59;
+const REMOVED_BINARY_OPERATORS = [
+	"|",
+	"^",
+	"&",
+	"<<",
+	">>",
+	">>>",
+	"**",
+	"%",
+	"??",
+	"===",
+	"!==",
+	"in",
+	"instanceof"
+];
+const REMOVED_UNARY_OPERATORS = ["~", "+"];
+const REMOVED_LITERALS = ["null"];
+const { Jsep } = jsep.default;
+function trimEnd(source, end) {
+	let result = Math.min(end, source.length);
+	while (result > 0 && /\s/.test(source.charAt(result - 1))) result -= 1;
+	return result;
+}
+function configure() {
+	for (const operator of REMOVED_BINARY_OPERATORS) Jsep.removeBinaryOp(operator);
+	for (const operator of REMOVED_UNARY_OPERATORS) Jsep.removeUnaryOp(operator);
+	for (const literal of REMOVED_LITERALS) Jsep.removeLiteral(literal);
+	jsep.default.plugins.register(_jsep_plugin_ternary.default);
+	jsep.default.hooks.add("gobble-spaces", function rejectSemicolon() {
+		if (this.code === SEMICOLON_CODE) this.throwError("Unexpected \";\"");
+	});
+	const { gobbleToken, gobbleIdentifier } = Jsep.prototype;
+	Jsep.prototype.gobbleToken = function stampToken() {
+		this.gobbleSpaces();
+		const start = this.index;
+		const node = gobbleToken.call(this);
+		if (node) {
+			node.start ??= start;
+			node.end ??= trimEnd(this.expr, this.index);
+		}
+		return node;
+	};
+	Jsep.prototype.gobbleIdentifier = function stampIdentifier() {
+		const start = this.index;
+		const node = gobbleIdentifier.call(this);
+		node.start = start;
+		node.end = this.index;
+		return node;
+	};
+}
+configure();
+function parseRaw(source) {
+	return (0, jsep.default)(source);
+}
+//#endregion
+//#region src/formula/parse.ts
+const FORMULA_LIMITS = {
+	maxLength: 500,
+	maxDepth: 32,
+	maxNodes: 200
+};
+var ParseFailure = class extends Error {
+	error;
+	constructor(error) {
+		super(error.code);
+		this.error = error;
+	}
+};
+function syntaxFailure(detail, span) {
+	return new ParseFailure({
+		code: "FORMULA_SYNTAX",
+		position: span.start,
+		length: span.end - span.start,
+		params: { detail }
+	});
+}
+function span$1(raw, children) {
+	return {
+		start: Math.min(raw.start ?? Number.POSITIVE_INFINITY, ...children.map((node) => node.start)),
+		end: Math.max(raw.end ?? Number.NEGATIVE_INFINITY, ...children.map((node) => node.end))
+	};
+}
+function child(raw) {
+	return raw;
+}
+function convertIdentifier(raw) {
+	return {
+		type: "Identifier",
+		name: String(raw.name),
+		...span$1(raw, [])
+	};
+}
+function convert(raw) {
+	switch (raw.type) {
+		case "Literal": return {
+			type: "Literal",
+			value: raw.value,
+			...span$1(raw, [])
+		};
+		case "Identifier": return convertIdentifier(raw);
+		case "MemberExpression": {
+			const property = child(raw.property);
+			if (raw.computed || raw.optional || property.type !== "Identifier") throw syntaxFailure("Only dotted access is supported", span$1(raw, []));
+			const object = convert(child(raw.object));
+			const identifier = convertIdentifier(property);
+			return {
+				type: "Member",
+				object,
+				property: identifier,
+				...span$1(raw, [object, identifier])
+			};
+		}
+		case "CallExpression": {
+			const callee = convert(child(raw.callee));
+			const args = raw.arguments.map(convert);
+			return {
+				type: "Call",
+				callee,
+				args,
+				...span$1(raw, [callee, ...args])
+			};
+		}
+		case "UnaryExpression": {
+			const operator = String(raw.operator);
+			const argument = convert(child(raw.argument));
+			return {
+				type: "Unary",
+				operator,
+				argument,
+				...span$1(raw, [argument])
+			};
+		}
+		case "BinaryExpression": {
+			const operator = String(raw.operator);
+			const left = convert(child(raw.left));
+			const right = convert(child(raw.right));
+			return {
+				type: "Binary",
+				operator,
+				left,
+				right,
+				...span$1(raw, [left, right])
+			};
+		}
+		case "ConditionalExpression": {
+			const test = convert(child(raw.test));
+			const consequent = convert(child(raw.consequent));
+			const alternate = convert(child(raw.alternate));
+			return {
+				type: "Conditional",
+				test,
+				consequent,
+				alternate,
+				...span$1(raw, [
+					test,
+					consequent,
+					alternate
+				])
+			};
+		}
+		case "Compound": throw syntaxFailure("Unexpected expression", raw.body.map(convert)[1]);
+		case "SequenceExpression": throw syntaxFailure("Sequences are not supported", raw.expressions.map(convert)[1]);
+		default: throw syntaxFailure(`${raw.type} is not supported`, span$1(raw, []));
+	}
+}
+function children(node) {
+	switch (node.type) {
+		case "Literal":
+		case "Identifier": return [];
+		case "Member": return [node.object, node.property];
+		case "Call": return [node.callee, ...node.args];
+		case "Unary": return [node.argument];
+		case "Binary": return [node.left, node.right];
+		case "Conditional": return [
+			node.test,
+			node.consequent,
+			node.alternate
+		];
+	}
+}
+function complexityFailure(limit, max, node) {
+	return new ParseFailure({
+		code: "FORMULA_TOO_COMPLEX",
+		position: node.start,
+		length: node.end - node.start,
+		params: {
+			limit,
+			max
+		}
+	});
+}
+function checkComplexity(root) {
+	let count = 0;
+	const visit = (node, depth) => {
+		if (depth > FORMULA_LIMITS.maxDepth) throw complexityFailure("DEPTH", FORMULA_LIMITS.maxDepth, node);
+		count += 1;
+		if (count > FORMULA_LIMITS.maxNodes) throw complexityFailure("NODES", FORMULA_LIMITS.maxNodes, node);
+		for (const next of children(node)) visit(next, depth + 1);
+	};
+	visit(root, 1);
+}
+function jsepFailure(source, thrown) {
+	const { index, description } = thrown;
+	return new ParseFailure({
+		code: "FORMULA_SYNTAX",
+		position: index,
+		length: Number(index < source.length),
+		params: { detail: description }
+	});
+}
+function parse(source) {
+	try {
+		if (source.length > FORMULA_LIMITS.maxLength) throw new ParseFailure({
+			code: "FORMULA_TOO_COMPLEX",
+			position: FORMULA_LIMITS.maxLength,
+			length: source.length - FORMULA_LIMITS.maxLength,
+			params: {
+				limit: "LENGTH",
+				max: FORMULA_LIMITS.maxLength
+			}
+		});
+		if (source.trim() === "") throw syntaxFailure("Formula is empty", {
+			start: 0,
+			end: source.length
+		});
+		let raw;
+		try {
+			raw = parseRaw(source);
+		} catch (thrown) {
+			throw jsepFailure(source, thrown);
+		}
+		const ast = convert(raw);
+		checkComplexity(ast);
+		return {
+			ok: true,
+			ast
+		};
+	} catch (thrown) {
+		if (!(thrown instanceof ParseFailure)) throw thrown;
+		return {
+			ok: false,
+			error: thrown.error
+		};
+	}
+}
+//#endregion
+//#region src/estimate/run-formula.ts
+function message(code, params) {
+	return params === void 0 ? { code } : {
+		code,
+		params: { ...params }
+	};
+}
+function runtimeError(reason) {
+	return {
+		ok: false,
+		error: message("FORMULA_RUNTIME_ERROR", { reason })
+	};
+}
+function runNumericFormula(source, scope) {
+	const parsed = parse(source);
+	if (!parsed.ok) return {
+		ok: false,
+		error: message(parsed.error.code, parsed.error.params)
+	};
+	const result = evaluate(parsed.ast, scope);
+	if (!result.ok) return {
+		ok: false,
+		error: message(result.error.code, result.error.params)
+	};
+	if (typeof result.value !== "number") return runtimeError("TYPE_MISMATCH");
+	if (result.value < 0) return runtimeError("NEGATIVE");
+	return {
+		ok: true,
+		value: result.value
+	};
+}
+//#endregion
+//#region src/estimate/materials.ts
+const isMaterialRule = (rule) => rule.quantityFormula !== null;
+function selectRule(data, categoryId, materialTypeId) {
+	const rules = data.rules.filter(isMaterialRule);
+	return rules.find((rule) => rule.level === "MATERIAL_TYPE" && rule.categoryId === categoryId && rule.materialTypeId === materialTypeId) ?? rules.find((rule) => rule.level === "CATEGORY" && rule.categoryId === categoryId);
+}
+function materialLine(configuration, data, room, categoryId, productId) {
+	const init = {
+		id: lineId("MATERIALS", room.clientId, categoryId),
+		section: "MATERIALS",
+		roomClientId: room.clientId,
+		categoryId,
+		productId
+	};
+	const category = data.categories.find((item) => item.id === categoryId);
+	const product = data.products.find((item) => item.id === productId && item.categoryId === categoryId);
+	if (product === void 0 || category === void 0 || !product.available) return failedLine(init, "UNAVAILABLE", {
+		code: "PRODUCT_UNAVAILABLE",
+		params: { productId }
+	});
+	const warnings = room.heatedFloor && category.surface === "FLOOR" && !product.heatedFloorCompatible ? [{
+		code: "HEATED_FLOOR_INCOMPATIBLE",
+		params: { productId }
+	}] : [];
+	const rule = selectRule(data, categoryId, product.materialTypeId);
+	if (rule === void 0) return failedLine({
+		...init,
+		warnings
+	}, "NOT_CALCULATED", {
+		code: "RULE_NOT_FOUND",
+		params: {
+			categoryId,
+			materialTypeId: product.materialTypeId
+		}
+	});
+	const variables = {
+		...roomVariables(room),
+		...productVariables(product, category),
+		...objectVariables(configuration)
+	};
+	const { coefficients } = data;
+	const ruled = {
+		...init,
+		warnings,
+		ruleId: rule.id
+	};
+	const quantity = runNumericFormula(rule.quantityFormula, {
+		variables,
+		coefficients
+	});
+	if (!quantity.ok) return failedLine(ruled, "ERROR", quantity.error);
+	const cost = runNumericFormula(rule.costFormula, {
+		variables: {
+			...variables,
+			quantity: quantity.value
+		},
+		coefficients
+	});
+	if (!cost.ok) return failedLine(ruled, "ERROR", cost.error);
+	return pricedLine({
+		...ruled,
+		quantity: roundQuantity(quantity.value),
+		unit: product.unit,
+		unitPriceCents: product.priceCents
+	}, cost.value);
+}
+function materialLines(configuration, data) {
+	return configuration.rooms.flatMap((room) => room.selections.flatMap(({ categoryId, productId }) => productId === null ? [] : [materialLine(configuration, data, room, categoryId, productId)]));
+}
+//#endregion
+//#region src/estimate/object-rules.ts
+function objectRuleLines(configuration, data) {
+	const scope = {
+		variables: objectVariables(configuration),
+		coefficients: data.coefficients
+	};
+	return data.rules.filter((rule) => rule.level === "OBJECT").sort((a, b) => a.sortOrder - b.sortOrder).map((rule) => {
+		const init = {
+			id: lineId("OBJECT", rule.id),
+			section: "OBJECT",
+			ruleId: rule.id
+		};
+		const outcome = runNumericFormula(rule.costFormula, scope);
+		return outcome.ok ? pricedLine(init, outcome.value) : failedLine(init, "ERROR", outcome.error);
+	});
+}
+//#endregion
+//#region src/schemas/common.ts
+const LocalizedTextSchema = zod.z.object({
+	en: zod.z.string(),
+	uk: zod.z.string()
+});
+const FinishLevelSchema = zod.z.enum(["ROUGH", "PRE_FINISH"]);
+const RuleLevelSchema = zod.z.enum([
+	"OBJECT",
+	"CATEGORY",
+	"MATERIAL_TYPE"
+]);
+const RateSourceSchema = zod.z.enum(["NBU", "MANUAL"]);
+const SurfaceKindSchema = zod.z.enum([
+	"NONE",
+	"FLOOR",
+	"WALLS",
+	"CEILING"
+]);
+const ProductUnitSchema = zod.z.enum([
+	"SQM",
+	"LINEAR_M",
+	"PIECE"
+]);
+const OptionUnitSchema = zod.z.enum([
+	"PIECE",
+	"ROOM_SQM",
+	"ROOM",
+	"PROJECT"
+]);
+const OptionKindSchema = zod.z.enum(["ENGINEERING", "ADDITIONAL"]);
+const RoomTypeCodeSchema = zod.z.enum([
+	"LIVING_ROOM",
+	"BEDROOM",
+	"KITCHEN",
+	"KITCHEN_LIVING",
+	"BATHROOM"
+]);
+const KitchenTypeSchema = zod.z.enum(["SEPARATE", "KITCHEN_LIVING"]);
+const CurrencySchema = zod.z.enum(["USD", "UAH"]);
+const SectionSchema = zod.z.enum([
+	"BASE",
+	"OBJECT",
+	"MATERIALS",
+	"ENGINEERING",
+	"ADDITIONAL"
+]);
+const LineStatusSchema = zod.z.enum([
+	"OK",
+	"INCLUDED",
+	"NOT_CALCULATED",
+	"UNAVAILABLE",
+	"ERROR"
+]);
+const CentsSchema = zod.z.int().min(0);
+const RangeSchema = zod.z.object({
+	min: zod.z.number(),
+	max: zod.z.number()
+});
+//#endregion
+//#region src/schemas/configuration.ts
+const RoomSelectionSchema = zod.z.object({
+	categoryId: zod.z.string(),
+	productId: zod.z.string().nullable()
+});
+const RoomConfigurationSchema = zod.z.object({
+	clientId: zod.z.string(),
+	roomTypeCode: RoomTypeCodeSchema,
+	lengthM: zod.z.number().positive(),
+	widthM: zod.z.number().positive(),
+	heightM: zod.z.number().positive(),
+	heatedFloor: zod.z.boolean(),
+	selections: zod.z.array(RoomSelectionSchema)
+});
+const OptionSelectionSchema = zod.z.object({
+	optionId: zod.z.string(),
+	quantity: zod.z.int().positive().optional(),
+	roomClientIds: zod.z.array(zod.z.string()).optional()
+});
+function duplicateIndexes(items, key) {
+	const seen = /* @__PURE__ */ new Set();
+	return items.flatMap((item, index) => {
+		const value = key(item);
+		if (seen.has(value)) return [index];
+		seen.add(value);
+		return [];
+	});
+}
+const ConfigurationSchema = zod.z.object({
+	finishLevel: FinishLevelSchema,
+	totalAreaSqm: zod.z.number().positive(),
+	balconyAreaSqm: zod.z.number().min(0),
+	balconyTiles: zod.z.boolean(),
+	gas: zod.z.boolean(),
+	kitchenType: KitchenTypeSchema,
+	rooms: zod.z.array(RoomConfigurationSchema),
+	options: zod.z.array(OptionSelectionSchema),
+	currency: CurrencySchema
+}).superRefine((configuration, ctx) => {
+	const addDuplicate = (path) => ctx.addIssue({
+		code: "custom",
+		path,
+		message: "Duplicate"
+	});
+	for (const index of duplicateIndexes(configuration.rooms, (room) => room.clientId)) addDuplicate([
+		"rooms",
+		index,
+		"clientId"
+	]);
+	configuration.rooms.forEach((room, roomIndex) => {
+		for (const index of duplicateIndexes(room.selections, (selection) => selection.categoryId)) addDuplicate([
+			"rooms",
+			roomIndex,
+			"selections",
+			index,
+			"categoryId"
+		]);
+	});
+	for (const index of duplicateIndexes(configuration.options, (option) => option.optionId)) addDuplicate([
+		"options",
+		index,
+		"optionId"
+	]);
+});
+//#endregion
+//#region src/schemas/pricing-data.ts
+const ExchangeRateSchema = zod.z.object({
+	rate: zod.z.string().regex(/^\d+\.\d{4}$/),
+	date: zod.z.string(),
+	source: RateSourceSchema
+});
+const PricingLimitsSchema = zod.z.object({
+	totalAreaSqm: RangeSchema,
+	rooms: RangeSchema,
+	roomSideM: RangeSchema,
+	roomHeightM: RangeSchema
+});
+const BaseRateSchema = zod.z.object({
+	finishLevel: FinishLevelSchema,
+	areaFromSqm: zod.z.number().min(0),
+	areaToSqm: zod.z.number(),
+	rateCentsPerSqm: zod.z.int().positive()
+});
+const PricingRuleSchema = zod.z.object({
+	id: zod.z.string(),
+	level: RuleLevelSchema,
+	categoryId: zod.z.string().nullable(),
+	materialTypeId: zod.z.string().nullable(),
+	name: LocalizedTextSchema,
+	quantityFormula: zod.z.string().nullable(),
+	costFormula: zod.z.string().max(500),
+	sortOrder: zod.z.int()
+}).refine((rule) => rule.level === "OBJECT" === (rule.quantityFormula === null), { path: ["quantityFormula"] });
+const PricingRoomTypeSchema = zod.z.object({
+	id: zod.z.string(),
+	code: zod.z.string()
+});
+const PricingCategorySchema = zod.z.object({
+	id: zod.z.string(),
+	wastePercent: zod.z.number().min(0),
+	surface: SurfaceKindSchema
+});
+const PricingMaterialTypeSchema = zod.z.object({
+	id: zod.z.string(),
+	code: zod.z.string()
+});
+const PricingProductSchema = zod.z.object({
+	id: zod.z.string(),
+	categoryId: zod.z.string(),
+	materialTypeId: zod.z.string(),
+	priceCents: CentsSchema,
+	unit: ProductUnitSchema,
+	wastePercentOverride: zod.z.number().min(0).nullable(),
+	heatedFloorCompatible: zod.z.boolean(),
+	available: zod.z.boolean()
+});
+const PricingPackageItemSchema = zod.z.object({
+	id: zod.z.string(),
+	includedInBase: zod.z.boolean(),
+	priceCents: CentsSchema.nullable(),
+	unit: OptionUnitSchema.nullable()
+});
+const PricingOptionSchema = zod.z.object({
+	id: zod.z.string(),
+	kind: OptionKindSchema,
+	priceCents: CentsSchema,
+	unit: OptionUnitSchema,
+	roomTypeCodes: zod.z.array(zod.z.string()),
+	minQuantity: zod.z.int().nullable(),
+	maxQuantity: zod.z.int().nullable(),
+	available: zod.z.boolean()
+});
+const PricingDataSchema = zod.z.object({
+	version: zod.z.string().regex(/^[0-9a-f]{16}$/),
+	exchangeRate: ExchangeRateSchema.nullable(),
+	limits: PricingLimitsSchema,
+	baseRates: zod.z.array(BaseRateSchema),
+	coefficients: zod.z.record(zod.z.string(), zod.z.number()),
+	rules: zod.z.array(PricingRuleSchema),
+	roomTypes: zod.z.array(PricingRoomTypeSchema),
+	categories: zod.z.array(PricingCategorySchema),
+	materialTypes: zod.z.array(PricingMaterialTypeSchema),
+	products: zod.z.array(PricingProductSchema),
+	packageItems: zod.z.array(PricingPackageItemSchema),
+	options: zod.z.array(PricingOptionSchema)
+});
+//#endregion
+//#region src/schemas/estimate.ts
+const EstimateMessageSchema = zod.z.object({
+	code: zod.z.string(),
+	params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+const EstimateLineSchema = zod.z.object({
+	id: zod.z.string(),
+	section: SectionSchema,
+	status: LineStatusSchema,
+	roomClientId: zod.z.string().nullable(),
+	categoryId: zod.z.string().nullable(),
+	productId: zod.z.string().nullable(),
+	optionId: zod.z.string().nullable(),
+	packageItemId: zod.z.string().nullable(),
+	ruleId: zod.z.string().nullable(),
+	quantity: zod.z.number().nullable(),
+	unit: zod.z.string().nullable(),
+	unitPriceCents: CentsSchema.nullable(),
+	amountCents: CentsSchema,
+	amountUahKopecks: CentsSchema.nullable(),
+	warnings: zod.z.array(EstimateMessageSchema),
+	error: EstimateMessageSchema.nullable()
+});
+const SectionTotalSchema = zod.z.object({
+	usdCents: CentsSchema,
+	uahKopecks: CentsSchema.nullable()
+});
+const EstimateTotalsSchema = zod.z.object({
+	usdCents: CentsSchema,
+	uahKopecks: CentsSchema.nullable(),
+	sections: zod.z.record(SectionSchema, SectionTotalSchema)
+});
+const EstimateWarningSchema = EstimateMessageSchema.extend({ lineId: zod.z.string().optional() });
+const EstimateSchema = zod.z.object({
+	pricingVersion: zod.z.string(),
+	currency: CurrencySchema,
+	exchangeRate: ExchangeRateSchema.nullable(),
+	lines: zod.z.array(EstimateLineSchema),
+	totals: EstimateTotalsSchema,
+	warnings: zod.z.array(EstimateWarningSchema),
+	incomplete: zod.z.boolean()
+});
+//#endregion
+//#region src/schemas/preview.ts
+const RuleSampleSchema = zod.z.object({
+	room: zod.z.object({
+		roomTypeCode: RoomTypeCodeSchema,
+		lengthM: zod.z.number().positive(),
+		widthM: zod.z.number().positive(),
+		heightM: zod.z.number().positive(),
+		heatedFloor: zod.z.boolean()
+	}).optional(),
+	product: zod.z.object({
+		priceCents: CentsSchema,
+		unit: ProductUnitSchema,
+		wastePercent: zod.z.number().min(0)
+	}).optional(),
+	object: zod.z.object({
+		totalAreaSqm: zod.z.number().positive(),
+		balconyAreaSqm: zod.z.number().min(0),
+		balconyTiles: zod.z.boolean(),
+		gas: zod.z.boolean(),
+		kitchenType: KitchenTypeSchema,
+		finishLevel: FinishLevelSchema,
+		roomsCount: zod.z.int().min(0),
+		bathroomsCount: zod.z.int().min(0)
+	})
+});
+const RulePreviewSchema = zod.z.object({
+	quantity: zod.z.number().nullable(),
+	amountCents: CentsSchema.nullable(),
+	variables: zod.z.record(zod.z.string(), zod.z.union([
+		zod.z.number(),
+		zod.z.boolean(),
+		zod.z.string()
+	])),
+	coefficients: zod.z.record(zod.z.string(), zod.z.number()),
+	error: EstimateMessageSchema.nullable()
+});
+//#endregion
+//#region src/estimate/totals.ts
+function sumTotal(lines, hasRate) {
+	return {
+		usdCents: lines.reduce((sum, line) => sum + line.amountCents, 0),
+		uahKopecks: hasRate ? lines.reduce((sum, line) => sum + (line.amountUahKopecks ?? 0), 0) : null
+	};
+}
+function computeTotals(lines, hasRate) {
+	const sections = Object.fromEntries(SectionSchema.options.map((section) => [section, sumTotal(lines.filter((line) => line.section === section), hasRate)]));
+	return {
+		...sumTotal(lines, hasRate),
+		sections
+	};
+}
+function collectWarnings(lines) {
+	return lines.flatMap((line) => line.warnings.map((warning) => ({
+		...warning,
+		lineId: line.id
+	})));
+}
+function isIncomplete(lines) {
+	return lines.some((line) => line.status === "ERROR" || line.status === "NOT_CALCULATED");
+}
+//#endregion
+//#region src/estimate/warnings.ts
+function roomsAreaWarnings(configuration) {
+	const roomsAreaSqm = Math.round(configuration.rooms.reduce((sum, room) => sum + roomVariables(room).floorArea, 0) * 1e4) / 1e4;
+	return roomsAreaSqm > configuration.totalAreaSqm ? [{
+		code: "ROOMS_AREA_EXCEEDS_TOTAL",
+		params: {
+			roomsAreaSqm,
+			totalAreaSqm: configuration.totalAreaSqm
+		}
+	}] : [];
+}
+function estimateWarnings(lines, configuration, rate) {
+	return [
+		...collectWarnings(lines),
+		...roomsAreaWarnings(configuration),
+		...configuration.currency === "UAH" && rate === null ? [{ code: "EXCHANGE_RATE_UNAVAILABLE" }] : []
+	];
+}
+//#endregion
+//#region src/estimate/estimate.ts
+function withKopecks(line, rate) {
+	return {
+		...line,
+		amountUahKopecks: rate === null ? null : convertCentsToKopecks(line.amountCents, rate)
+	};
+}
+function estimate(configuration, data) {
+	const rate = data.exchangeRate?.rate ?? null;
+	const lines = [
+		baseLine(configuration, data),
+		...objectRuleLines(configuration, data),
+		...materialLines(configuration, data),
+		...engineeringLines(configuration, data),
+		...additionalLines(configuration, data)
+	].map((line) => withKopecks(line, rate));
+	return {
+		pricingVersion: data.version,
+		currency: configuration.currency,
+		exchangeRate: data.exchangeRate,
+		lines,
+		totals: computeTotals(lines, rate !== null),
+		warnings: estimateWarnings(lines, configuration, rate),
+		incomplete: isIncomplete(lines)
+	};
+}
+//#endregion
+//#region src/estimate/limits.ts
+function checkLimits(configuration, limits, options = []) {
+	const violations = [];
+	const check = (field, value, min, max) => {
+		if (value < min || value > max) violations.push({
+			field,
+			min,
+			max
+		});
+	};
+	check("totalAreaSqm", configuration.totalAreaSqm, limits.totalAreaSqm.min, limits.totalAreaSqm.max);
+	check("balconyAreaSqm", configuration.balconyAreaSqm, 0, configuration.totalAreaSqm);
+	check("rooms", configuration.rooms.length, limits.rooms.min, limits.rooms.max);
+	configuration.rooms.forEach((room, index) => {
+		const path = `rooms[${index}]`;
+		check(`${path}.lengthM`, room.lengthM, limits.roomSideM.min, limits.roomSideM.max);
+		check(`${path}.widthM`, room.widthM, limits.roomSideM.min, limits.roomSideM.max);
+		check(`${path}.heightM`, room.heightM, limits.roomHeightM.min, limits.roomHeightM.max);
+	});
+	configuration.options.forEach((selection, index) => {
+		const option = options.find((candidate) => candidate.id === selection.optionId);
+		if (option?.unit !== "PIECE" || selection.quantity === void 0) return;
+		check(`options[${index}].quantity`, selection.quantity, option.minQuantity ?? 1, option.maxQuantity ?? Number.MAX_SAFE_INTEGER);
+	});
+	return violations;
+}
+//#endregion
+//#region src/formula/preview.ts
+function collectReferences(node, found) {
+	switch (node.type) {
+		case "Identifier":
+			found.variables.add(node.name);
+			return;
+		case "Member":
+			if (node.object.type === "Identifier" && node.object.name === "coef") found.coefficients.add(node.property.name);
+			return;
+		case "Call":
+			node.args.forEach((argument) => collectReferences(argument, found));
+			return;
+		case "Unary":
+			collectReferences(node.argument, found);
+			return;
+		case "Binary":
+			collectReferences(node.left, found);
+			collectReferences(node.right, found);
+			return;
+		case "Conditional":
+			collectReferences(node.test, found);
+			collectReferences(node.consequent, found);
+			collectReferences(node.alternate, found);
+			return;
+		case "Literal": return;
+	}
+}
+function referencesOf(sources) {
+	const found = {
+		variables: /* @__PURE__ */ new Set(),
+		coefficients: /* @__PURE__ */ new Set()
+	};
+	for (const source of sources) {
+		const parsed = source === null ? void 0 : parse(source);
+		if (parsed?.ok) collectReferences(parsed.ast, found);
+	}
+	return found;
+}
+function objectScope({ object }) {
+	return {
+		totalArea: object.totalAreaSqm,
+		balconyArea: object.balconyAreaSqm,
+		balconyTiles: object.balconyTiles,
+		gas: object.gas,
+		kitchenType: object.kitchenType,
+		finishLevel: object.finishLevel,
+		roomsCount: object.roomsCount,
+		bathroomsCount: object.bathroomsCount
+	};
+}
+function scopeOf(level, sample) {
+	if (level === "OBJECT") return { scope: objectScope(sample) };
+	const { room, product } = sample;
+	if (room === void 0 || product === void 0) return { error: {
+		code: "SAMPLE_INCOMPLETE",
+		params: { missing: room === void 0 ? "room" : "product" }
+	} };
+	return { scope: {
+		...roomVariables(room),
+		...productVariablesOf(product, product.wastePercent),
+		...objectScope(sample)
+	} };
+}
+function pick(source, names) {
+	return Object.fromEntries(Object.entries(source).filter(([name]) => names.has(name)));
+}
+function previewRule(input) {
+	const { level, quantityFormula, costFormula, coefficients } = input;
+	const references = referencesOf([quantityFormula, costFormula]);
+	const report = (variables, quantity, amountCents, error) => ({
+		quantity,
+		amountCents,
+		variables: pick(variables, references.variables),
+		coefficients: pick(coefficients, references.coefficients),
+		error
+	});
+	if (level === "OBJECT" !== (quantityFormula === null)) return report({}, null, null, { code: "QUANTITY_FORMULA_MISMATCH" });
+	const prepared = scopeOf(level, input.sample);
+	if ("error" in prepared) return report({}, null, null, prepared.error);
+	let variables = prepared.scope;
+	let quantity = null;
+	if (quantityFormula !== null) {
+		const raw = runNumericFormula(quantityFormula, {
+			variables,
+			coefficients
+		});
+		if (!raw.ok) return report(variables, null, null, raw.error);
+		variables = {
+			...variables,
+			quantity: raw.value
+		};
+		quantity = roundQuantity(raw.value);
+	}
+	const cost = runNumericFormula(costFormula, {
+		variables,
+		coefficients
+	});
+	if (!cost.ok) return report(variables, quantity, null, cost.error);
+	const line = pricedLine({
+		id: "preview",
+		section: "OBJECT"
+	}, cost.value);
+	return line.error === null ? report(variables, quantity, line.amountCents, null) : report(variables, quantity, null, line.error);
+}
+//#endregion
+//#region src/formula/suggest.ts
+function levenshtein(a, b) {
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		const current = [i];
+		for (let j = 1; j <= b.length; j++) {
+			const substitution = a[i - 1] === b[j - 1] ? 0 : 1;
+			current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + substitution);
+		}
+		previous = current;
+	}
+	return previous[b.length];
+}
+function suggestNearest(name, candidates, maxDistance = 2) {
+	let best;
+	let bestDistance = maxDistance + 1;
+	for (const candidate of candidates) {
+		const distance = levenshtein(name, candidate);
+		if (distance < bestDistance || distance === bestDistance && best !== void 0 && candidate < best) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+//#endregion
+//#region src/formula/validate.ts
+const NUMBER = { kind: "number" };
+const BOOLEAN = { kind: "boolean" };
+const STRING = { kind: "string" };
+const UNKNOWN = { kind: "unknown" };
+function typeName(type) {
+	return type.kind === "enum" ? type.name : type.kind;
+}
+const number = (name) => ({
+	name,
+	kind: "number"
+});
+const boolean = (name) => ({
+	name,
+	kind: "boolean"
+});
+const enumeration = (name, values) => ({
+	name,
+	kind: "enum",
+	values
+});
+const FORMULA_SCOPE_VARIABLES = {
+	room: [
+		number("length"),
+		number("width"),
+		number("height"),
+		number("floorArea"),
+		number("perimeter"),
+		number("wallArea"),
+		boolean("heatedFloor"),
+		enumeration("roomType", RoomTypeCodeSchema.options)
+	],
+	product: [
+		number("price"),
+		number("waste"),
+		enumeration("unit", ProductUnitSchema.options)
+	],
+	object: [
+		number("totalArea"),
+		number("balconyArea"),
+		boolean("balconyTiles"),
+		boolean("gas"),
+		enumeration("kitchenType", KitchenTypeSchema.options),
+		enumeration("finishLevel", FinishLevelSchema.options),
+		number("roomsCount"),
+		number("bathroomsCount")
+	]
+};
+const FORMULA_QUANTITY_VARIABLE = number("quantity");
+const FORMULA_VARIABLES = {
+	OBJECT: FORMULA_SCOPE_VARIABLES.object,
+	CATEGORY: [
+		...FORMULA_SCOPE_VARIABLES.room,
+		...FORMULA_SCOPE_VARIABLES.product,
+		...FORMULA_SCOPE_VARIABLES.object
+	],
+	MATERIAL_TYPE: [
+		...FORMULA_SCOPE_VARIABLES.room,
+		...FORMULA_SCOPE_VARIABLES.product,
+		...FORMULA_SCOPE_VARIABLES.object
+	]
+};
+const ALL_VARIABLE_NAMES = new Set(FORMULA_VARIABLES.CATEGORY.map((variable) => variable.name));
+function span(node) {
+	return {
+		position: node.start,
+		length: node.end - node.start
+	};
+}
+function validateFormula(input) {
+	const parsed = parse(input.source);
+	if (!parsed.ok) return {
+		valid: false,
+		coefficientKeys: [],
+		errors: [parsed.error]
+	};
+	const variables = FORMULA_VARIABLES[input.level];
+	const variableTypes = new Map(variables.map((variable) => [variable.name, variable.kind === "enum" ? {
+		kind: "enum",
+		name: variable.name,
+		values: variable.values ?? []
+	} : { kind: variable.kind }]));
+	const allowedNames = variables.map((variable) => variable.name);
+	const knownCoefficients = new Set(input.coefficientKeys);
+	const usedCoefficients = /* @__PURE__ */ new Set();
+	const errors = [];
+	const quantityAllowed = input.kind === "cost" && input.level !== "OBJECT";
+	function mismatch(node, expected) {
+		errors.push({
+			code: "FORMULA_SYNTAX",
+			...span(node),
+			params: {
+				reason: "TYPE_MISMATCH",
+				expected
+			}
+		});
+	}
+	function expectType(node, expected) {
+		const type = infer(node);
+		if (type.kind === "unknown") return false;
+		if (type.kind !== expected) {
+			mismatch(node, expected);
+			return false;
+		}
+		return true;
+	}
+	function identifier(node) {
+		const { name } = node;
+		if (name === FORMULA_QUANTITY_VARIABLE.name) {
+			if (!quantityAllowed) {
+				errors.push({
+					code: "QUANTITY_NOT_ALLOWED",
+					...span(node)
+				});
+				return UNKNOWN;
+			}
+			return NUMBER;
+		}
+		const type = variableTypes.get(name);
+		if (type !== void 0) return type;
+		if (ALL_VARIABLE_NAMES.has(name)) {
+			errors.push({
+				code: "VARIABLE_NOT_ALLOWED_AT_LEVEL",
+				...span(node),
+				params: {
+					variable: name,
+					level: input.level
+				}
+			});
+			return UNKNOWN;
+		}
+		const suggestion = suggestNearest(name, allowedNames);
+		errors.push({
+			code: "UNKNOWN_VARIABLE",
+			...span(node),
+			params: suggestion === void 0 ? { name } : {
+				name,
+				suggestion
+			}
+		});
+		return UNKNOWN;
+	}
+	function member(node) {
+		const { object, property } = node;
+		if (object.type !== "Identifier" || object.name !== "coef") {
+			errors.push({
+				code: "UNKNOWN_VARIABLE",
+				...span(node),
+				params: { name: input.source.slice(node.start, node.end) }
+			});
+			return UNKNOWN;
+		}
+		usedCoefficients.add(property.name);
+		if (!knownCoefficients.has(property.name)) {
+			errors.push({
+				code: "UNKNOWN_COEFFICIENT",
+				...span(node),
+				params: { key: property.name }
+			});
+			return UNKNOWN;
+		}
+		return NUMBER;
+	}
+	function call(node) {
+		const { callee } = node;
+		const fn = callee.type === "Identifier" ? FORMULA_FUNCTION_TABLE.get(callee.name) : void 0;
+		if (fn === void 0) {
+			errors.push({
+				code: "UNKNOWN_FUNCTION",
+				...span(callee),
+				params: { name: input.source.slice(callee.start, callee.end) }
+			});
+			for (const argument of node.args) infer(argument);
+			return UNKNOWN;
+		}
+		let sound = true;
+		if (node.args.length < fn.minArgs || node.args.length > fn.maxArgs) {
+			errors.push({
+				code: "FORMULA_SYNTAX",
+				...span(node),
+				params: {
+					reason: "ARGUMENT_COUNT",
+					min: fn.minArgs,
+					...Number.isFinite(fn.maxArgs) ? { max: fn.maxArgs } : {}
+				}
+			});
+			sound = false;
+		}
+		for (const argument of node.args) sound = expectType(argument, "number") && sound;
+		return sound ? NUMBER : UNKNOWN;
+	}
+	function enumLiteral(literal, other) {
+		const type = infer(other);
+		if (type.kind === "unknown") return;
+		if (other.type !== "Identifier" || type.kind !== "enum") {
+			mismatch(other, "enum variable");
+			return;
+		}
+		if (!type.values.includes(literal.value)) errors.push({
+			code: "FORMULA_SYNTAX",
+			...span(literal),
+			params: {
+				reason: "UNKNOWN_ENUM_VALUE",
+				value: literal.value,
+				variable: type.name
+			}
+		});
+	}
+	function equality(node) {
+		const { left, right } = node;
+		const literal = [left, right].find((side) => side.type === "Literal" && typeof side.value === "string");
+		if (literal !== void 0) {
+			enumLiteral(literal, literal === left ? right : left);
+			return BOOLEAN;
+		}
+		const a = infer(left);
+		const b = infer(right);
+		if (a.kind !== "unknown" && b.kind !== "unknown" && a.kind !== b.kind) mismatch(right, typeName(a));
+		return BOOLEAN;
+	}
+	function binary(node) {
+		const { operator, left, right } = node;
+		if (operator === "==" || operator === "!=") return equality(node);
+		const logical = operator === "&&" || operator === "||";
+		const operand = logical ? "boolean" : "number";
+		const leftSound = expectType(left, operand);
+		const rightSound = expectType(right, operand);
+		if (!(leftSound && rightSound)) return UNKNOWN;
+		const arithmetic = [
+			"+",
+			"-",
+			"*",
+			"/"
+		].includes(operator);
+		return logical || !arithmetic ? BOOLEAN : NUMBER;
+	}
+	function unary(node) {
+		const operand = node.operator === "!" ? "boolean" : "number";
+		return expectType(node.argument, operand) ? { kind: operand } : UNKNOWN;
+	}
+	function conditional(node) {
+		const testSound = expectType(node.test, "boolean");
+		const consequent = infer(node.consequent);
+		const alternate = infer(node.alternate);
+		if (consequent.kind === "unknown") return alternate;
+		if (alternate.kind === "unknown") return consequent;
+		if (consequent.kind !== alternate.kind) {
+			mismatch(node.alternate, typeName(consequent));
+			return UNKNOWN;
+		}
+		return testSound ? consequent : UNKNOWN;
+	}
+	function infer(node) {
+		switch (node.type) {
+			case "Literal":
+				if (typeof node.value === "string") return STRING;
+				return typeof node.value === "number" ? NUMBER : BOOLEAN;
+			case "Identifier": return identifier(node);
+			case "Member": return member(node);
+			case "Call": return call(node);
+			case "Unary": return unary(node);
+			case "Binary": return binary(node);
+			case "Conditional": return conditional(node);
+		}
+	}
+	const resultType = infer(parsed.ast);
+	if (resultType.kind !== "unknown" && resultType.kind !== "number") mismatch(parsed.ast, "number");
+	return {
+		valid: errors.length === 0,
+		coefficientKeys: [...usedCoefficients],
+		errors
+	};
+}
+//#endregion
+exports.BaseRateSchema = BaseRateSchema;
+exports.COEFFICIENT_NAMESPACE = COEFFICIENT_NAMESPACE;
+exports.CentsSchema = CentsSchema;
+exports.ConfigurationSchema = ConfigurationSchema;
+exports.CurrencySchema = CurrencySchema;
+exports.EstimateLineSchema = EstimateLineSchema;
+exports.EstimateMessageSchema = EstimateMessageSchema;
+exports.EstimateSchema = EstimateSchema;
+exports.EstimateTotalsSchema = EstimateTotalsSchema;
+exports.EstimateWarningSchema = EstimateWarningSchema;
+exports.ExchangeRateSchema = ExchangeRateSchema;
+exports.FORMULA_FUNCTIONS = FORMULA_FUNCTIONS;
+exports.FORMULA_FUNCTION_TABLE = FORMULA_FUNCTION_TABLE;
+exports.FORMULA_LIMITS = FORMULA_LIMITS;
+exports.FORMULA_QUANTITY_VARIABLE = FORMULA_QUANTITY_VARIABLE;
+exports.FORMULA_SCOPE_VARIABLES = FORMULA_SCOPE_VARIABLES;
+exports.FORMULA_VARIABLES = FORMULA_VARIABLES;
+exports.FinishLevelSchema = FinishLevelSchema;
+exports.KitchenTypeSchema = KitchenTypeSchema;
+exports.LineStatusSchema = LineStatusSchema;
+exports.LocalizedTextSchema = LocalizedTextSchema;
+exports.OptionKindSchema = OptionKindSchema;
+exports.OptionSelectionSchema = OptionSelectionSchema;
+exports.OptionUnitSchema = OptionUnitSchema;
+exports.PricingCategorySchema = PricingCategorySchema;
+exports.PricingDataSchema = PricingDataSchema;
+exports.PricingLimitsSchema = PricingLimitsSchema;
+exports.PricingMaterialTypeSchema = PricingMaterialTypeSchema;
+exports.PricingOptionSchema = PricingOptionSchema;
+exports.PricingPackageItemSchema = PricingPackageItemSchema;
+exports.PricingProductSchema = PricingProductSchema;
+exports.PricingRoomTypeSchema = PricingRoomTypeSchema;
+exports.PricingRuleSchema = PricingRuleSchema;
+exports.ProductUnitSchema = ProductUnitSchema;
+exports.RangeSchema = RangeSchema;
+exports.RateSourceSchema = RateSourceSchema;
+exports.RoomConfigurationSchema = RoomConfigurationSchema;
+exports.RoomSelectionSchema = RoomSelectionSchema;
+exports.RoomTypeCodeSchema = RoomTypeCodeSchema;
+exports.RuleLevelSchema = RuleLevelSchema;
+exports.RulePreviewSchema = RulePreviewSchema;
+exports.RuleSampleSchema = RuleSampleSchema;
+exports.SectionSchema = SectionSchema;
+exports.SectionTotalSchema = SectionTotalSchema;
+exports.SurfaceKindSchema = SurfaceKindSchema;
+exports.checkLimits = checkLimits;
+exports.convertCentsToKopecks = convertCentsToKopecks;
+exports.estimate = estimate;
+exports.evaluate = evaluate;
+exports.levenshtein = levenshtein;
+exports.objectVariables = objectVariables;
+exports.parse = parse;
+exports.previewRule = previewRule;
+exports.productVariables = productVariables;
+exports.productVariablesOf = productVariablesOf;
+exports.roomVariables = roomVariables;
+exports.suggestNearest = suggestNearest;
+exports.toCents = toCents;
+exports.validateFormula = validateFormula;