@roomwise/calc-engine 0.7.0 → 0.9.0

package/README.md

@@ -47,7 +47,7 @@ Lines are produced in this order: base cost, object rules (by `sortOrder`), mate
 - Base cost: `OBJECT` rules with `baseComponent: true`, one `BASE` line each. Only in `FULL`; a line that is `OK` with a zero amount is left out.
 - Object rules: the other `OBJECT` level rules, one line each.
 - Materials: for every room selection with a product, the `MATERIAL_TYPE` rule for the category and the product's material type is used if one exists, otherwise the `CATEGORY` rule. Without either, the line is `NOT_CALCULATED` (`RULE_NOT_FOUND`). Unknown or unavailable products give `UNAVAILABLE`. Each line carries [components](#line-components).
-- Engineering and additional: package items marked `includedInBase` become `INCLUDED` lines with a zero amount, and are skipped in `PARTIAL`. Options are priced by unit (`PIECE`, `ROOM_SQM`, `ROOM`, `PROJECT`). An option has exactly one price source: `priceCents` with no `priceCoefficientKeys`, or `priceCents: null` with keys, in which case the unit price is the sum of those coefficients in dollars (`PricingDataSchema` rejects both and neither; read the price from the line's `unitPriceCents`). A missing coefficient gives an `ERROR` line (`UNKNOWN_COEFFICIENT`). An option whose `scopes` do not include the configuration scope is `UNAVAILABLE` with `OPTION_SCOPE_NOT_ALLOWED`.
+- Engineering and additional: package items marked `includedInBase` become `INCLUDED` lines with a zero amount. In `PARTIAL` no package items are priced at all; the section holds only options. Options are priced by unit (`PIECE`, `ROOM_SQM`, `ROOM`, `PROJECT`). An option has exactly one price source: `priceCents` with no `priceCoefficientKeys`, or `priceCents: null` with keys, in which case the unit price is the sum of those coefficients in dollars (`PricingDataSchema` rejects both and neither; read the price from the line's `unitPriceCents`). A missing coefficient gives an `ERROR` line (`UNKNOWN_COEFFICIENT`). An option whose `scopes` do not include the configuration scope is `UNAVAILABLE` with `OPTION_SCOPE_NOT_ALLOWED`.
 
 Result fields:
 
@@ -193,7 +193,7 @@ Every schema is a zod schema with an inferred type of the same name without the
 | `totalAreaSqm` | required | `null` |
 | `BASE` section | `OBJECT` rules with `baseComponent: true`, one line each | none |
 | Material lines | `MATERIAL` component only | `MATERIAL`, `LABOR` and `PREP` components |
-| Package items with `includedInBase` | `INCLUDED` lines | skipped |
+| Engineering package items | priced, `INCLUDED` with `includedInBase` | none |
 | `totalArea` variable | `totalAreaSqm` | `roomsFloorArea` |
 | Area warnings | `ROOMS_AREA_EXCEEDS_TOTAL`, `ROOMS_AREA_BELOW_TOTAL` | none |
 
@@ -203,11 +203,12 @@ The base cost has no per-area rate table. It is built from rules whose formulas
 
 A material line is the sum of its components:
 
-- `MATERIAL`: the rule's `costFormula`.
+- `MATERIAL`: the rule's `costFormula`. When the pricing data lists accompanying materials in `accessories`, this is the product itself and the accessories are separate components.
+- `ACCESSORY`: an accompanying material such as underlay or tile glue, with the `coefficientKey` it comes from. Only accessory coefficients referenced by the formula count. The formula is evaluated with all of them set to zero for the `MATERIAL` part and once per accessory with only that coefficient restored; when the parts do not add up to the full cost, as in `(price + coef.a) * (1 + coef.b)`, the line is not split. Parts are rounded to cents and the rounding remainder goes to the last `ACCESSORY`; an accessory left at zero is dropped. A formula that uses `heatedFloor ? coef.a : coef.b` yields only the branch in effect. If any evaluation fails, the parts do not add up or a part would be negative, the line keeps a single `MATERIAL` component. Surface, object and option lines are not split.
 - `LABOR`: the rule's `laborFormula`, which only `CATEGORY` and `MATERIAL_TYPE` rules can have. It is evaluated in `PARTIAL` only. Without a formula the component is 0 and the line gets `LABOR_RATE_MISSING`.
 - `PREP`: surface preparation, from a `SURFACE` rule.
 
-Every component is rounded to whole cents on its own and `amountCents` is the sum of the rounded components. A `FULL` line has a single `MATERIAL` component. Each component carries the `ruleId` of the rule that produced it; ids are plain strings.
+Every component is rounded to whole cents on its own and `amountCents` is the sum of the rounded components. A `FULL` line has a `MATERIAL` component and its `ACCESSORY` components, if any. Each component carries the `ruleId` of the rule that produced it; ids are plain strings.
 
 ### Surface preparation
 
@@ -256,7 +257,7 @@ Availability by rule level:
 - `CATEGORY` and `MATERIAL_TYPE`: room, product and object variables. `quantity` is available in cost and labor formulas, not in the quantity formula. `laborFormula` sees the same variables as `costFormula`.
 - `SURFACE`: room and object variables plus `surfaceArea` and `puttyRequired`. `quantity` and the product variables are not available.
 
-Coefficients are read as `coef.<key>`; keys come from the pricing data. The cost and labor formulas receive `quantity` unrounded, while the line shows it rounded to 3 decimals.
+Coefficients are read as `coef.<key>`; keys come from the pricing data. `PricingData.accessories` is an optional map from coefficient key to a `{ en, uk }` name; the keys that exist in `coefficients` are the accompanying materials shown as `ACCESSORY` components, and the name is looked up by `coefficientKey`. The cost and labor formulas receive `quantity` unrounded, while the line shows it rounded to 3 decimals.
 
 ### Syntax
 

package/dist/index.cjs

@@ -322,7 +322,9 @@ function packageLine(configuration, item) {
 	}, item.priceCents / 100 * quantity);
 }
 function engineeringLines(configuration, data) {
-	return [...(configuration.scope === "PARTIAL" ? data.packageItems.filter((item) => !item.includedInBase) : data.packageItems).map((item) => packageLine(configuration, item)), ...optionLines(configuration, data, "ENGINEERING")];
+	const options = optionLines(configuration, data, "ENGINEERING");
+	if (configuration.scope === "PARTIAL") return options;
+	return [...data.packageItems.map((item) => packageLine(configuration, item)), ...options];
 }
 //#endregion
 //#region src/formula/language.ts
@@ -361,121 +363,6 @@ const FORMULA_FUNCTION_TABLE = new Map([
 ].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 = [
@@ -724,6 +611,121 @@ function parse(source) {
 	}
 }
 //#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/estimate/run-formula.ts
 function message(code, params) {
 	return params === void 0 ? { code } : {
@@ -833,11 +835,108 @@ function applySurfacePrep(data, room, lines, objectScope) {
 }
 //#endregion
 //#region src/estimate/materials.ts
+const ADDITIVITY_TOLERANCE = 1e-9;
 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 referencedCoefficients(source) {
+	const keys = /* @__PURE__ */ new Set();
+	const parsed = parse(source);
+	if (!parsed.ok) return keys;
+	const visit = (node) => {
+		switch (node.type) {
+			case "Member":
+				if (node.object.type === "Identifier" && node.object.name === "coef") keys.add(node.property.name);
+				visit(node.object);
+				return;
+			case "Call":
+				visit(node.callee);
+				node.args.forEach(visit);
+				return;
+			case "Unary":
+				visit(node.argument);
+				return;
+			case "Binary":
+				visit(node.left);
+				visit(node.right);
+				return;
+			case "Conditional":
+				visit(node.test);
+				visit(node.consequent);
+				visit(node.alternate);
+				return;
+			default: return;
+		}
+	};
+	visit(parsed.ast);
+	return keys;
+}
+function splitAccessories(rule, data, variables, fullValue, fullCents) {
+	const whole = [{
+		kind: "MATERIAL",
+		ruleId: rule.id,
+		amountCents: fullCents
+	}];
+	const accessories = data.accessories ?? {};
+	const keys = [...referencedCoefficients(rule.costFormula)].filter((key) => Object.hasOwn(accessories, key) && Object.hasOwn(data.coefficients, key));
+	if (keys.length === 0) return whole;
+	const zeroed = Object.fromEntries(keys.map((key) => [key, 0]));
+	const costValue = (overrides) => {
+		const outcome = runNumericFormula(rule.costFormula, {
+			variables,
+			coefficients: {
+				...data.coefficients,
+				...overrides
+			}
+		});
+		return outcome.ok ? outcome.value : null;
+	};
+	const productValue = costValue(zeroed);
+	if (productValue === null) return whole;
+	const productCents = componentCents(productValue);
+	if (productCents === null) return whole;
+	const parts = [];
+	for (const key of keys) {
+		const withKey = costValue({
+			...zeroed,
+			[key]: data.coefficients[key]
+		});
+		if (withKey === null || withKey < productValue) return whole;
+		parts.push({
+			key,
+			value: withKey - productValue
+		});
+	}
+	const partsValue = parts.reduce((sum, part) => sum + part.value, 0);
+	if (Math.abs(productValue + partsValue - fullValue) > ADDITIVITY_TOLERANCE * Math.max(1, Math.abs(fullValue))) return whole;
+	const priced = [];
+	for (const part of parts) {
+		const cents = componentCents(part.value);
+		if (cents === null) return whole;
+		priced.push({
+			key: part.key,
+			cents
+		});
+	}
+	const remainder = fullCents - productCents - priced.reduce((sum, part) => sum + part.cents, 0);
+	const last = priced[priced.length - 1];
+	last.cents += remainder;
+	if (last.cents < 0) return whole;
+	const kept = priced.filter((part) => part.cents > 0);
+	if (kept.length === 0) return whole;
+	return [{
+		kind: "MATERIAL",
+		ruleId: rule.id,
+		amountCents: productCents
+	}, ...kept.map((part) => ({
+		kind: "ACCESSORY",
+		ruleId: rule.id,
+		coefficientKey: part.key,
+		amountCents: part.cents
+	}))];
+}
 function materialLine(configuration, data, room, selection, objectScope) {
 	const { categoryId } = selection;
 	const productId = selection.productId;
@@ -901,11 +1000,10 @@ function materialLine(configuration, data, room, selection, objectScope) {
 	if (!cost.ok) return failedLine(ruled, "ERROR", cost.error);
 	const materialCents = componentCents(cost.value);
 	if (materialCents === null) return failedLine(ruled, "ERROR", outOfRange());
-	const components = [{
-		kind: "MATERIAL",
-		ruleId: rule.id,
-		amountCents: materialCents
-	}];
+	const components = splitAccessories(rule, data, {
+		...variables,
+		quantity: quantity.value
+	}, cost.value, materialCents);
 	const lineWarnings = [...warnings];
 	if (configuration.scope === "PARTIAL") {
 		let laborCents = 0;
@@ -1025,6 +1123,7 @@ const SectionSchema = zod.z.enum([
 ]);
 const LineComponentKindSchema = zod.z.enum([
 	"MATERIAL",
+	"ACCESSORY",
 	"LABOR",
 	"PREP"
 ]);
@@ -1210,6 +1309,7 @@ const PricingDataSchema = zod.z.object({
 	exchangeRate: ExchangeRateSchema.nullable(),
 	limits: PricingLimitsSchema,
 	coefficients: zod.z.record(zod.z.string(), zod.z.number()),
+	accessories: zod.z.record(zod.z.string(), LocalizedTextSchema).optional(),
 	rules: zod.z.array(PricingRuleSchema),
 	roomTypes: zod.z.array(PricingRoomTypeSchema),
 	categories: zod.z.array(PricingCategorySchema),
@@ -1228,7 +1328,11 @@ const LineComponentSchema = zod.z.object({
 	kind: LineComponentKindSchema,
 	ruleId: zod.z.string(),
 	amountCents: zod.z.number().int().min(0),
-	sharedWithCategoryId: zod.z.string().optional()
+	sharedWithCategoryId: zod.z.string().optional(),
+	coefficientKey: zod.z.string().optional()
+}).refine((component) => component.kind === "ACCESSORY" === (component.coefficientKey !== void 0), {
+	path: ["coefficientKey"],
+	message: "coefficientKey is required for ACCESSORY and only for it"
 });
 const EstimateLineSchema = zod.z.object({
 	id: zod.z.string(),

package/dist/index.d.cts

@@ -82,6 +82,7 @@ export declare const SectionSchema: z.ZodEnum<{
 export type Section = z.infer<typeof SectionSchema>;
 export declare const LineComponentKindSchema: z.ZodEnum<{
   MATERIAL: "MATERIAL";
+  ACCESSORY: "ACCESSORY";
   LABOR: "LABOR";
   PREP: "PREP";
 }>;
@@ -194,12 +195,14 @@ export type EstimateMessage = z.infer<typeof EstimateMessageSchema>;
 export declare const LineComponentSchema: z.ZodObject<{
   kind: z.ZodEnum<{
     MATERIAL: "MATERIAL";
+    ACCESSORY: "ACCESSORY";
     LABOR: "LABOR";
     PREP: "PREP";
   }>;
   ruleId: z.ZodString;
   amountCents: z.ZodNumber;
   sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+  coefficientKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LineComponent = z.infer<typeof LineComponentSchema>;
 export declare const EstimateLineSchema: z.ZodObject<{
@@ -232,12 +235,14 @@ export declare const EstimateLineSchema: z.ZodObject<{
   components: z.ZodOptional<z.ZodArray<z.ZodObject<{
     kind: z.ZodEnum<{
       MATERIAL: "MATERIAL";
+      ACCESSORY: "ACCESSORY";
       LABOR: "LABOR";
       PREP: "PREP";
     }>;
     ruleId: z.ZodString;
     amountCents: z.ZodNumber;
     sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+    coefficientKey: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>;
   warnings: z.ZodArray<z.ZodObject<{
     code: z.ZodString;
@@ -319,12 +324,14 @@ export declare const EstimateSchema: z.ZodObject<{
     components: z.ZodOptional<z.ZodArray<z.ZodObject<{
       kind: z.ZodEnum<{
         MATERIAL: "MATERIAL";
+        ACCESSORY: "ACCESSORY";
         LABOR: "LABOR";
         PREP: "PREP";
       }>;
       ruleId: z.ZodString;
       amountCents: z.ZodNumber;
       sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+      coefficientKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     warnings: z.ZodArray<z.ZodObject<{
       code: z.ZodString;
@@ -589,6 +596,10 @@ export declare const PricingDataSchema: z.ZodObject<{
     missingAreaHintSqm: z.ZodNumber;
   }, z.core.$strip>;
   coefficients: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  accessories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    en: z.ZodString;
+    uk: z.ZodString;
+  }, z.core.$strip>>>;
   rules: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     level: z.ZodEnum<{

package/dist/index.d.ts

@@ -82,6 +82,7 @@ export declare const SectionSchema: z.ZodEnum<{
 export type Section = z.infer<typeof SectionSchema>;
 export declare const LineComponentKindSchema: z.ZodEnum<{
   MATERIAL: "MATERIAL";
+  ACCESSORY: "ACCESSORY";
   LABOR: "LABOR";
   PREP: "PREP";
 }>;
@@ -194,12 +195,14 @@ export type EstimateMessage = z.infer<typeof EstimateMessageSchema>;
 export declare const LineComponentSchema: z.ZodObject<{
   kind: z.ZodEnum<{
     MATERIAL: "MATERIAL";
+    ACCESSORY: "ACCESSORY";
     LABOR: "LABOR";
     PREP: "PREP";
   }>;
   ruleId: z.ZodString;
   amountCents: z.ZodNumber;
   sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+  coefficientKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LineComponent = z.infer<typeof LineComponentSchema>;
 export declare const EstimateLineSchema: z.ZodObject<{
@@ -232,12 +235,14 @@ export declare const EstimateLineSchema: z.ZodObject<{
   components: z.ZodOptional<z.ZodArray<z.ZodObject<{
     kind: z.ZodEnum<{
       MATERIAL: "MATERIAL";
+      ACCESSORY: "ACCESSORY";
       LABOR: "LABOR";
       PREP: "PREP";
     }>;
     ruleId: z.ZodString;
     amountCents: z.ZodNumber;
     sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+    coefficientKey: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>;
   warnings: z.ZodArray<z.ZodObject<{
     code: z.ZodString;
@@ -319,12 +324,14 @@ export declare const EstimateSchema: z.ZodObject<{
     components: z.ZodOptional<z.ZodArray<z.ZodObject<{
       kind: z.ZodEnum<{
         MATERIAL: "MATERIAL";
+        ACCESSORY: "ACCESSORY";
         LABOR: "LABOR";
         PREP: "PREP";
       }>;
       ruleId: z.ZodString;
       amountCents: z.ZodNumber;
       sharedWithCategoryId: z.ZodOptional<z.ZodString>;
+      coefficientKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     warnings: z.ZodArray<z.ZodObject<{
       code: z.ZodString;
@@ -589,6 +596,10 @@ export declare const PricingDataSchema: z.ZodObject<{
     missingAreaHintSqm: z.ZodNumber;
   }, z.core.$strip>;
   coefficients: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  accessories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    en: z.ZodString;
+    uk: z.ZodString;
+  }, z.core.$strip>>>;
   rules: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     level: z.ZodEnum<{

package/dist/index.js

@@ -297,7 +297,9 @@ function packageLine(configuration, item) {
 	}, item.priceCents / 100 * quantity);
 }
 function engineeringLines(configuration, data) {
-	return [...(configuration.scope === "PARTIAL" ? data.packageItems.filter((item) => !item.includedInBase) : data.packageItems).map((item) => packageLine(configuration, item)), ...optionLines(configuration, data, "ENGINEERING")];
+	const options = optionLines(configuration, data, "ENGINEERING");
+	if (configuration.scope === "PARTIAL") return options;
+	return [...data.packageItems.map((item) => packageLine(configuration, item)), ...options];
 }
 //#endregion
 //#region src/formula/language.ts
@@ -336,121 +338,6 @@ const FORMULA_FUNCTION_TABLE = new Map([
 ].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 = [
@@ -699,6 +586,121 @@ function parse(source) {
 	}
 }
 //#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/estimate/run-formula.ts
 function message(code, params) {
 	return params === void 0 ? { code } : {
@@ -808,11 +810,108 @@ function applySurfacePrep(data, room, lines, objectScope) {
 }
 //#endregion
 //#region src/estimate/materials.ts
+const ADDITIVITY_TOLERANCE = 1e-9;
 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 referencedCoefficients(source) {
+	const keys = /* @__PURE__ */ new Set();
+	const parsed = parse(source);
+	if (!parsed.ok) return keys;
+	const visit = (node) => {
+		switch (node.type) {
+			case "Member":
+				if (node.object.type === "Identifier" && node.object.name === "coef") keys.add(node.property.name);
+				visit(node.object);
+				return;
+			case "Call":
+				visit(node.callee);
+				node.args.forEach(visit);
+				return;
+			case "Unary":
+				visit(node.argument);
+				return;
+			case "Binary":
+				visit(node.left);
+				visit(node.right);
+				return;
+			case "Conditional":
+				visit(node.test);
+				visit(node.consequent);
+				visit(node.alternate);
+				return;
+			default: return;
+		}
+	};
+	visit(parsed.ast);
+	return keys;
+}
+function splitAccessories(rule, data, variables, fullValue, fullCents) {
+	const whole = [{
+		kind: "MATERIAL",
+		ruleId: rule.id,
+		amountCents: fullCents
+	}];
+	const accessories = data.accessories ?? {};
+	const keys = [...referencedCoefficients(rule.costFormula)].filter((key) => Object.hasOwn(accessories, key) && Object.hasOwn(data.coefficients, key));
+	if (keys.length === 0) return whole;
+	const zeroed = Object.fromEntries(keys.map((key) => [key, 0]));
+	const costValue = (overrides) => {
+		const outcome = runNumericFormula(rule.costFormula, {
+			variables,
+			coefficients: {
+				...data.coefficients,
+				...overrides
+			}
+		});
+		return outcome.ok ? outcome.value : null;
+	};
+	const productValue = costValue(zeroed);
+	if (productValue === null) return whole;
+	const productCents = componentCents(productValue);
+	if (productCents === null) return whole;
+	const parts = [];
+	for (const key of keys) {
+		const withKey = costValue({
+			...zeroed,
+			[key]: data.coefficients[key]
+		});
+		if (withKey === null || withKey < productValue) return whole;
+		parts.push({
+			key,
+			value: withKey - productValue
+		});
+	}
+	const partsValue = parts.reduce((sum, part) => sum + part.value, 0);
+	if (Math.abs(productValue + partsValue - fullValue) > ADDITIVITY_TOLERANCE * Math.max(1, Math.abs(fullValue))) return whole;
+	const priced = [];
+	for (const part of parts) {
+		const cents = componentCents(part.value);
+		if (cents === null) return whole;
+		priced.push({
+			key: part.key,
+			cents
+		});
+	}
+	const remainder = fullCents - productCents - priced.reduce((sum, part) => sum + part.cents, 0);
+	const last = priced[priced.length - 1];
+	last.cents += remainder;
+	if (last.cents < 0) return whole;
+	const kept = priced.filter((part) => part.cents > 0);
+	if (kept.length === 0) return whole;
+	return [{
+		kind: "MATERIAL",
+		ruleId: rule.id,
+		amountCents: productCents
+	}, ...kept.map((part) => ({
+		kind: "ACCESSORY",
+		ruleId: rule.id,
+		coefficientKey: part.key,
+		amountCents: part.cents
+	}))];
+}
 function materialLine(configuration, data, room, selection, objectScope) {
 	const { categoryId } = selection;
 	const productId = selection.productId;
@@ -876,11 +975,10 @@ function materialLine(configuration, data, room, selection, objectScope) {
 	if (!cost.ok) return failedLine(ruled, "ERROR", cost.error);
 	const materialCents = componentCents(cost.value);
 	if (materialCents === null) return failedLine(ruled, "ERROR", outOfRange());
-	const components = [{
-		kind: "MATERIAL",
-		ruleId: rule.id,
-		amountCents: materialCents
-	}];
+	const components = splitAccessories(rule, data, {
+		...variables,
+		quantity: quantity.value
+	}, cost.value, materialCents);
 	const lineWarnings = [...warnings];
 	if (configuration.scope === "PARTIAL") {
 		let laborCents = 0;
@@ -1000,6 +1098,7 @@ const SectionSchema = z.enum([
 ]);
 const LineComponentKindSchema = z.enum([
 	"MATERIAL",
+	"ACCESSORY",
 	"LABOR",
 	"PREP"
 ]);
@@ -1185,6 +1284,7 @@ const PricingDataSchema = z.object({
 	exchangeRate: ExchangeRateSchema.nullable(),
 	limits: PricingLimitsSchema,
 	coefficients: z.record(z.string(), z.number()),
+	accessories: z.record(z.string(), LocalizedTextSchema).optional(),
 	rules: z.array(PricingRuleSchema),
 	roomTypes: z.array(PricingRoomTypeSchema),
 	categories: z.array(PricingCategorySchema),
@@ -1203,7 +1303,11 @@ const LineComponentSchema = z.object({
 	kind: LineComponentKindSchema,
 	ruleId: z.string(),
 	amountCents: z.number().int().min(0),
-	sharedWithCategoryId: z.string().optional()
+	sharedWithCategoryId: z.string().optional(),
+	coefficientKey: z.string().optional()
+}).refine((component) => component.kind === "ACCESSORY" === (component.coefficientKey !== void 0), {
+	path: ["coefficientKey"],
+	message: "coefficientKey is required for ACCESSORY and only for it"
 });
 const EstimateLineSchema = z.object({
 	id: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roomwise/calc-engine",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",