@solumflow-app/crm-mcp-server 0.2.0 → 0.3.0

package/dist/index.js

@@ -47,7 +47,7 @@ ${snippet}
 }
 
 // src/catalog-tools.ts
-var CONTENT_BLOCKS = 'Besides plain values (text, number, choice), a product can carry content blocks, three field types: "content_text" is { html, links? } with already-sanitised html; "cta" is { heading, body, primary: {label,url}, secondary? }, a call to action; "repeater" is { items: [{ id, ...one value per item field }] } and covers lists, accordions (FAQ), downloads and testimonials. A repeater\u2019s field says how to draw it: "display" is "list" or "accordion", "preset" names where it started (list, faq, downloads, testimonials), "itemFields" is the structure of one item (key, label, type: text, richtext, url {label,url}, icon {set,name}, image or file {url,name,size,contentType}) and "titleKey" is the item field that names an item, such as the question of a FAQ. A block that is public but empty is null; a block that is not public is not there at all.';
+var CONTENT_BLOCKS = 'Besides plain values (text, number, choice), a product can carry content blocks, three field types: "content_text" is { html, links? } with already-sanitised html; "cta" is { heading, body, primary: {label,url}, secondary? }, a call to action; "repeater" is { items: [{ id, ...one value per item field }] } and covers lists, accordions (FAQ), downloads and testimonials. A repeater\u2019s field says how to draw it: "display" is "list" or "accordion", "preset" names where it started (list, faq, downloads, testimonials), "itemFields" is the structure of one item (key, label, type: text, richtext, url {label,url}, icon {set,name}, image or file {url,name,size,contentType}) and "titleKey" is the item field that names an item, such as the question of a FAQ. A "configurator" is a 3D product configurator: a listing carries only { configurator: true }, a product\u2019s own page the whole document (see read_configurator). A block that is public but empty is null; a block that is not public is not there at all.';
 var slugOrId = z.string().min(1).max(200).describe("The address (slug) or the id of the product.");
 function registerCatalogTools(server, client) {
   server.registerTool(
@@ -105,14 +105,1869 @@ function describeField(field) {
   return `- ${field.slug}: ${field.label}, repeater (${field.display ?? "list"}${preset}; items: ${items}${title})`;
 }
 
-// src/placement-tools.ts
+// src/configurator-tools.ts
+import { z as z5 } from "zod";
+
+// ../features/product-configurator/src/shared/configurator-limits.ts
+var CONFIGURATOR_LIMITS = {
+  structureBytes: 64 * 1024,
+  valueBytes: 32 * 1024,
+  parameters: 60,
+  tabs: 12,
+  choiceLists: 40,
+  optionsPerList: 60,
+  materials: 120,
+  priceGroups: 20,
+  amounts: 20,
+  rules: 80,
+  priceRules: 20,
+  presets: 60,
+  formulaChars: 200,
+  formulaNodes: 64,
+  formulaDepth: 8,
+  geometryInputs: 60,
+  geometryConstants: 60,
+  geometrySlots: 20,
+  geometryNodes: 200,
+  expandedParts: 200,
+  repeatCount: 12,
+  repeatDepth: 2,
+  annotations: 30
+};
+function jsonByteLength(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length + jsonbSpacing(value);
+}
+function jsonbSpacing(value) {
+  if (Array.isArray(value)) {
+    return Math.max(0, value.length - 1) + value.reduce((sum, item) => sum + jsonbSpacing(item), 0);
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.values(value).filter(
+      (item) => item !== void 0
+    );
+    return entries.length + Math.max(0, entries.length - 1) + entries.reduce((sum, item) => sum + jsonbSpacing(item), 0);
+  }
+  return 0;
+}
+
+// ../features/product-configurator/src/shared/configurator-issue.ts
+function issue(path, code, params) {
+  return params ? { path, code, params } : { path, code };
+}
+function formatIssuePath(path) {
+  return path.reduce((text, part) => {
+    if (typeof part === "number") {
+      return `${text}[${part}]`;
+    }
+    return text ? `${text}.${part}` : part;
+  }, "");
+}
+
+// ../features/product-configurator/src/shared/evaluate-formula.ts
+var FUNCTIONS = ["min", "max", "floor", "ceil", "round", "abs"];
+var NAME_START = /[a-z_]/;
+var NAME_PART = /[a-z0-9_]/;
+function tokenize(source) {
+  const tokens = [];
+  let index = 0;
+  while (index < source.length) {
+    const char = source.charAt(index);
+    if (char === " " || char === "	" || char === "\n") {
+      index += 1;
+      continue;
+    }
+    if (/[0-9.]/.test(char)) {
+      let end = index;
+      while (end < source.length && /[0-9.]/.test(source.charAt(end))) {
+        end += 1;
+      }
+      const text = source.slice(index, end);
+      if (!/^(\d+(\.\d+)?|\.\d+)$/.test(text)) {
+        return null;
+      }
+      tokens.push({ type: "number", value: Number(text) });
+      index = end;
+      continue;
+    }
+    if (NAME_START.test(char)) {
+      let end = index;
+      while (end < source.length && NAME_PART.test(source.charAt(end))) {
+        end += 1;
+      }
+      tokens.push({ type: "name", value: source.slice(index, end) });
+      index = end;
+      continue;
+    }
+    const operator = char === "\xD7" ? "*" : char === "\xF7" ? "/" : char === "\u2212" ? "-" : char;
+    if (operator === "+" || operator === "-" || operator === "*" || operator === "/" || operator === "(" || operator === ")" || operator === ",") {
+      tokens.push({ type: "op", value: operator });
+      index += 1;
+      continue;
+    }
+    return null;
+  }
+  return tokens;
+}
+var FormulaParser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.position = 0;
+    this.nodes = 0;
+    this.depth = 0;
+    this.names = [];
+  }
+  parse() {
+    const node = this.expression();
+    if (this.position !== this.tokens.length) {
+      throw new FormulaSyntaxError("formula_syntax");
+    }
+    return node;
+  }
+  count(node) {
+    this.nodes += 1;
+    if (this.nodes > CONFIGURATOR_LIMITS.formulaNodes) {
+      throw new FormulaSyntaxError("formula_too_many_nodes");
+    }
+    return node;
+  }
+  peek() {
+    return this.tokens[this.position];
+  }
+  takeOperator(value) {
+    const token = this.peek();
+    if (token?.type === "op" && token.value === value) {
+      this.position += 1;
+      return true;
+    }
+    return false;
+  }
+  expression() {
+    let left = this.term();
+    for (; ; ) {
+      if (this.takeOperator("+")) {
+        left = this.count({
+          kind: "binary",
+          operator: "+",
+          left,
+          right: this.term()
+        });
+      } else if (this.takeOperator("-")) {
+        left = this.count({
+          kind: "binary",
+          operator: "-",
+          left,
+          right: this.term()
+        });
+      } else {
+        return left;
+      }
+    }
+  }
+  term() {
+    let left = this.unary();
+    for (; ; ) {
+      if (this.takeOperator("*")) {
+        left = this.count({
+          kind: "binary",
+          operator: "*",
+          left,
+          right: this.unary()
+        });
+      } else if (this.takeOperator("/")) {
+        left = this.count({
+          kind: "binary",
+          operator: "/",
+          left,
+          right: this.unary()
+        });
+      } else {
+        return left;
+      }
+    }
+  }
+  unary() {
+    if (this.takeOperator("-")) {
+      return this.count({ kind: "negate", operand: this.unary() });
+    }
+    if (this.takeOperator("+")) {
+      return this.unary();
+    }
+    return this.primary();
+  }
+  nested(read) {
+    this.depth += 1;
+    if (this.depth > CONFIGURATOR_LIMITS.formulaDepth) {
+      throw new FormulaSyntaxError("formula_too_deep");
+    }
+    const result = read();
+    this.depth -= 1;
+    return result;
+  }
+  primary() {
+    const token = this.peek();
+    if (!token) {
+      throw new FormulaSyntaxError("formula_syntax");
+    }
+    if (token.type === "number") {
+      this.position += 1;
+      return this.count({ kind: "number", value: token.value });
+    }
+    if (token.type === "name") {
+      this.position += 1;
+      if (this.takeOperator("(")) {
+        if (!FUNCTIONS.includes(token.value)) {
+          throw new FormulaSyntaxError("formula_unknown_function", token.value);
+        }
+        const fn = token.value;
+        return this.nested(() => {
+          const args = [this.expression()];
+          while (this.takeOperator(",")) {
+            args.push(this.expression());
+          }
+          if (!this.takeOperator(")")) {
+            throw new FormulaSyntaxError("formula_syntax");
+          }
+          const variadic = fn === "min" || fn === "max";
+          if (!variadic && args.length !== 1) {
+            throw new FormulaSyntaxError("formula_syntax", fn);
+          }
+          return this.count({ kind: "call", fn, args });
+        });
+      }
+      if (!this.names.includes(token.value)) {
+        this.names.push(token.value);
+      }
+      return this.count({ kind: "name", name: token.value });
+    }
+    if (token.value === "(") {
+      this.position += 1;
+      return this.nested(() => {
+        const inner = this.expression();
+        if (!this.takeOperator(")")) {
+          throw new FormulaSyntaxError("formula_syntax");
+        }
+        return inner;
+      });
+    }
+    throw new FormulaSyntaxError("formula_syntax");
+  }
+};
+var FormulaSyntaxError = class extends Error {
+  constructor(code, detail) {
+    super(code);
+    this.code = code;
+    this.detail = detail;
+  }
+};
+var parsedCache = /* @__PURE__ */ new Map();
+function parseFormula(source) {
+  if (typeof source === "number") {
+    if (!Number.isFinite(source)) {
+      return { ok: false, code: "formula_syntax" };
+    }
+    return {
+      ok: true,
+      formula: { source, root: { kind: "number", value: source }, names: [] }
+    };
+  }
+  const cached = parsedCache.get(source);
+  if (cached) {
+    return cached;
+  }
+  const result = parseUncached(source);
+  if (parsedCache.size > 2e3) {
+    parsedCache.clear();
+  }
+  parsedCache.set(source, result);
+  return result;
+}
+function parseUncached(source) {
+  if (source.length > CONFIGURATOR_LIMITS.formulaChars) {
+    return { ok: false, code: "formula_too_long" };
+  }
+  const tokens = tokenize(source);
+  if (!tokens || tokens.length === 0) {
+    return { ok: false, code: "formula_syntax" };
+  }
+  const parser = new FormulaParser(tokens);
+  try {
+    const root = parser.parse();
+    return { ok: true, formula: { source, root, names: parser.names } };
+  } catch (error) {
+    if (error instanceof FormulaSyntaxError) {
+      return { ok: false, code: error.code, detail: error.detail };
+    }
+    throw error;
+  }
+}
+function evaluateFormula(formula, scope) {
+  for (const name of formula.names) {
+    if (!Object.prototype.hasOwnProperty.call(scope, name)) {
+      return { ok: false, code: "formula_unknown_name", name };
+    }
+  }
+  const value = evaluateNode(formula.root, scope);
+  if (!Number.isFinite(value)) {
+    return { ok: false, code: "formula_not_finite" };
+  }
+  return { ok: true, value };
+}
+function evaluateNode(node, scope) {
+  switch (node.kind) {
+    case "number":
+      return node.value;
+    case "name":
+      return scope[node.name] ?? Number.NaN;
+    case "negate":
+      return -evaluateNode(node.operand, scope);
+    case "binary":
+      return applyOperator(
+        node.operator,
+        evaluateNode(node.left, scope),
+        evaluateNode(node.right, scope)
+      );
+    case "call":
+      return applyFunction(
+        node.fn,
+        node.args.map((arg) => evaluateNode(arg, scope))
+      );
+  }
+}
+function applyOperator(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      return left / right;
+  }
+}
+function applyFunction(fn, args) {
+  const first = args[0] ?? Number.NaN;
+  switch (fn) {
+    case "min":
+      return Math.min(...args);
+    case "max":
+      return Math.max(...args);
+    case "floor":
+      return Math.floor(first);
+    case "ceil":
+      return Math.ceil(first);
+    case "round":
+      return Math.round(first);
+    case "abs":
+      return Math.abs(first);
+  }
+}
+function formulaNames(source) {
+  const parsed = parseFormula(source);
+  return parsed.ok ? { ok: true, names: parsed.formula.names } : parsed;
+}
+function evaluateFormulaSource(source, scope) {
+  const parsed = parseFormula(source);
+  return parsed.ok ? evaluateFormula(parsed.formula, scope) : parsed;
+}
+
+// ../features/product-configurator/src/shared/geometry-document.schema.ts
 import { z as z2 } from "zod";
+var CONFIGURATOR_NAME_PATTERN = /^[a-z][a-z0-9_]{0,39}$/;
+var CONFIGURATOR_CODE_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/;
+var ConfiguratorNameSchema = z2.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
+var ConfiguratorCodeSchema = z2.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
+var FormulaSchema = z2.union([
+  z2.number().finite(),
+  z2.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
+]);
+var Vector3Schema = z2.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
+var PRIMITIVE_TYPES = [
+  "box",
+  "rounded_top_box",
+  "stadium_prism",
+  "arc_panel",
+  "led_strip",
+  "niche_panel"
+];
+var PRIMITIVE_PARAMS = {
+  box: { required: [], optional: [] },
+  // The front top edge, rounded over its whole width.
+  rounded_top_box: { required: ["radius"], optional: [] },
+  // A stadium (a rectangle with half-round ends) seen from the front,
+  // extruded over the depth.
+  stadium_prism: { required: [], optional: [] },
+  // A quarter of an elliptical shell in plan view, filling the block's width
+  // and depth; `mirror` 0 bends it towards the right, 1 towards the left.
+  arc_panel: { required: ["thickness"], optional: ["mirror"] },
+  // A thin strip that gives light.
+  led_strip: { required: [], optional: [] },
+  // A wall with a rectangular opening, measured from the block's own corner.
+  niche_panel: {
+    required: ["niche_x", "niche_y", "niche_width", "niche_height"],
+    optional: []
+  }
+};
+var PrimitiveNodeSchema = z2.strictObject({
+  id: ConfiguratorNameSchema,
+  type: z2.enum(PRIMITIVE_TYPES),
+  slot: ConfiguratorNameSchema,
+  size: Vector3Schema,
+  at: Vector3Schema,
+  visible: FormulaSchema.optional(),
+  params: z2.record(ConfiguratorNameSchema, FormulaSchema).optional()
+});
+var GeometryNodeSchema = z2.lazy(
+  () => z2.union([
+    PrimitiveNodeSchema,
+    z2.strictObject({
+      id: ConfiguratorNameSchema,
+      type: z2.literal("repeat"),
+      count: FormulaSchema,
+      index: z2.enum(["i", "j"]).optional(),
+      visible: FormulaSchema.optional(),
+      children: z2.array(GeometryNodeSchema).min(1)
+    })
+  ])
+);
+var GeometryBindingSchema = z2.strictObject({
+  param: ConfiguratorNameSchema,
+  map: z2.record(ConfiguratorCodeSchema, z2.number().finite()).optional()
+});
+var GeometryInputSchema = z2.strictObject({
+  name: ConfiguratorNameSchema,
+  binding: GeometryBindingSchema
+});
+var GeometrySlotSchema = z2.strictObject({
+  name: ConfiguratorNameSchema,
+  param: ConfiguratorNameSchema.optional(),
+  material: ConfiguratorCodeSchema.optional(),
+  color: z2.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional()
+});
+var GeometryAnnotationSchema = z2.strictObject({
+  id: ConfiguratorNameSchema,
+  axis: z2.enum(["x", "y"]),
+  from: FormulaSchema,
+  to: FormulaSchema,
+  at: FormulaSchema,
+  label: z2.string().trim().min(1).max(80).optional()
+});
+var GeometryDocumentSchema = z2.strictObject({
+  /** Rises with every new upload, so a product page can say which one it shows. */
+  version: z2.number().int().min(1),
+  /** The starter document this one was copied from, for information only. */
+  startedFrom: z2.string().trim().max(80).optional(),
+  inputs: z2.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
+  constants: z2.record(ConfiguratorNameSchema, z2.number().finite()),
+  slots: z2.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
+  root: z2.array(GeometryNodeSchema).min(1),
+  camera: z2.strictObject({
+    /** Degrees around the vertical axis, 0 is straight on. */
+    azimuth: z2.number().min(-90).max(90),
+    /** Degrees above the horizon. */
+    elevation: z2.number().min(-10).max(80)
+  }).optional(),
+  annotations: z2.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+});
+
+// ../features/product-configurator/src/shared/geometry-document-problems.ts
+function geometryDocumentProblems(document, context = {}) {
+  const base = context.path ?? [];
+  const problems = [];
+  const constantNames = Object.keys(document.constants);
+  if (constantNames.length > CONFIGURATOR_LIMITS.geometryConstants) {
+    problems.push(
+      issue([...base, "constants"], "configurator.tooMany", {
+        max: CONFIGURATOR_LIMITS.geometryConstants
+      })
+    );
+  }
+  const inputNames = /* @__PURE__ */ new Set();
+  document.inputs.forEach((input, index) => {
+    const path = [...base, "inputs", index];
+    if (inputNames.has(input.name) || constantNames.includes(input.name)) {
+      problems.push(
+        issue([...path, "name"], "configurator.duplicateName", {
+          name: input.name
+        })
+      );
+    }
+    if (input.name === "i" || input.name === "j") {
+      problems.push(
+        issue([...path, "name"], "configurator.reservedName", {
+          name: input.name
+        })
+      );
+    }
+    inputNames.add(input.name);
+    if (!context.parameters) {
+      return;
+    }
+    const parameter = context.parameters.get(input.binding.param);
+    if (!parameter) {
+      problems.push(
+        issue([...path, "binding", "param"], "configurator.inputUnbound", {
+          name: input.name,
+          param: input.binding.param
+        })
+      );
+      return;
+    }
+    if (parameter.kind === "material") {
+      problems.push(
+        issue(
+          [...path, "binding", "param"],
+          "configurator.inputCannotBindMaterial",
+          {
+            name: input.name
+          }
+        )
+      );
+    }
+    if (parameter.kind === "choice") {
+      const missing = (parameter.codes ?? []).filter(
+        (code) => input.binding.map?.[code] === void 0
+      );
+      if (missing.length > 0) {
+        problems.push(
+          issue(
+            [...path, "binding", "map"],
+            "configurator.choiceMapIncomplete",
+            {
+              name: input.name,
+              codes: missing.join(", ")
+            }
+          )
+        );
+      }
+    } else if (input.binding.map) {
+      problems.push(
+        issue([...path, "binding", "map"], "configurator.mapOnlyForChoice", {
+          name: input.name
+        })
+      );
+    }
+  });
+  const slotNames = /* @__PURE__ */ new Set();
+  document.slots.forEach((slot, index) => {
+    const path = [...base, "slots", index];
+    if (slotNames.has(slot.name)) {
+      problems.push(
+        issue([...path, "name"], "configurator.duplicateName", {
+          name: slot.name
+        })
+      );
+    }
+    slotNames.add(slot.name);
+    const sources = [slot.param, slot.material, slot.color].filter(
+      (source) => source !== void 0
+    );
+    if (sources.length !== 1) {
+      problems.push(
+        issue(path, "configurator.slotNeedsOneSource", { name: slot.name })
+      );
+    }
+    if (slot.param && context.parameters) {
+      const parameter = context.parameters.get(slot.param);
+      if (parameter?.kind !== "material") {
+        problems.push(
+          issue([...path, "param"], "configurator.slotParamNotMaterial", {
+            param: slot.param
+          })
+        );
+      }
+    }
+    if (slot.material && context.materialCodes && !context.materialCodes.has(slot.material)) {
+      problems.push(
+        issue([...path, "material"], "configurator.unknownMaterial", {
+          code: slot.material
+        })
+      );
+    }
+  });
+  const shapeNames = /* @__PURE__ */ new Set([...inputNames, ...constantNames]);
+  const ids = /* @__PURE__ */ new Set();
+  let declared = 0;
+  const checkFormula2 = (formula, path, scope) => {
+    const names = formulaNames(formula);
+    if (!names.ok) {
+      problems.push(issue(path, `configurator.${names.code}`));
+      return;
+    }
+    for (const name of names.names) {
+      if (!scope.has(name)) {
+        problems.push(issue(path, "configurator.unknownName", { name }));
+      }
+    }
+  };
+  const walk = (nodes, path, scope, repeatDepth) => {
+    for (const node of nodes) {
+      const nodePath = [...path, node.id];
+      declared += 1;
+      if (ids.has(node.id)) {
+        problems.push(
+          issue([...nodePath, "id"], "configurator.duplicateId", {
+            id: node.id
+          })
+        );
+      }
+      ids.add(node.id);
+      if (node.visible !== void 0) {
+        checkFormula2(node.visible, [...nodePath, "visible"], scope);
+      }
+      if (node.type === "repeat") {
+        checkFormula2(node.count, [...nodePath, "count"], scope);
+        if (repeatDepth + 1 > CONFIGURATOR_LIMITS.repeatDepth) {
+          problems.push(
+            issue(nodePath, "configurator.repeatTooDeep", {
+              max: CONFIGURATOR_LIMITS.repeatDepth
+            })
+          );
+          continue;
+        }
+        const index = node.index ?? "i";
+        if (scope.has(index)) {
+          problems.push(
+            issue([...nodePath, "index"], "configurator.indexInUse", { index })
+          );
+        }
+        walk(
+          node.children,
+          nodePath,
+          /* @__PURE__ */ new Set([...scope, index]),
+          repeatDepth + 1
+        );
+        continue;
+      }
+      if (!slotNames.has(node.slot)) {
+        problems.push(
+          issue([...nodePath, "slot"], "configurator.unknownSlot", {
+            slot: node.slot
+          })
+        );
+      }
+      node.size.forEach(
+        (formula, axis) => checkFormula2(formula, [...nodePath, "size", axis], scope)
+      );
+      node.at.forEach(
+        (formula, axis) => checkFormula2(formula, [...nodePath, "at", axis], scope)
+      );
+      const allowed = PRIMITIVE_PARAMS[node.type];
+      const given = node.params ?? {};
+      for (const required of allowed.required) {
+        if (given[required] === void 0) {
+          problems.push(
+            issue(
+              [...nodePath, "params", required],
+              "configurator.missingBlockParam",
+              {
+                type: node.type,
+                param: required
+              }
+            )
+          );
+        }
+      }
+      for (const [key, formula] of Object.entries(given)) {
+        if (!allowed.required.includes(key) && !allowed.optional.includes(key)) {
+          problems.push(
+            issue(
+              [...nodePath, "params", key],
+              "configurator.unknownBlockParam",
+              {
+                type: node.type,
+                param: key
+              }
+            )
+          );
+          continue;
+        }
+        checkFormula2(formula, [...nodePath, "params", key], scope);
+      }
+    }
+  };
+  walk(document.root, [...base, "root"], shapeNames, 0);
+  if (declared > CONFIGURATOR_LIMITS.geometryNodes) {
+    problems.push(
+      issue([...base, "root"], "configurator.tooMany", {
+        max: CONFIGURATOR_LIMITS.geometryNodes
+      })
+    );
+  }
+  const annotationIds = /* @__PURE__ */ new Set();
+  document.annotations.forEach((annotation, index) => {
+    const path = [...base, "annotations", index];
+    if (annotationIds.has(annotation.id)) {
+      problems.push(
+        issue([...path, "id"], "configurator.duplicateId", {
+          id: annotation.id
+        })
+      );
+    }
+    annotationIds.add(annotation.id);
+    checkFormula2(annotation.from, [...path, "from"], shapeNames);
+    checkFormula2(annotation.to, [...path, "to"], shapeNames);
+    checkFormula2(annotation.at, [...path, "at"], shapeNames);
+  });
+  return problems;
+}
+
+// ../features/product-configurator/src/shared/configurator-structure.schema.ts
+import { z as z3 } from "zod";
+var LabelSchema = z3.string().trim().min(1).max(80);
+var CONFIGURATOR_TEXTURE_PATH_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.(webp|jpg|jpeg)$/;
+var TexturePathSchema = z3.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
+var ParameterBase = {
+  key: ConfiguratorNameSchema,
+  label: LabelSchema,
+  tab: ConfiguratorNameSchema
+};
+var ConfiguratorParameterSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({
+    ...ParameterBase,
+    kind: z3.literal("number"),
+    /** `mm` is a measure, `count` a number of things (compartments). */
+    unit: z3.enum(["mm", "count"]),
+    step: z3.number().positive().finite(),
+    /** The widest range any model may offer; a model narrows it in its value. */
+    min: z3.number().finite(),
+    max: z3.number().finite()
+  }),
+  z3.strictObject({
+    ...ParameterBase,
+    kind: z3.literal("choice"),
+    list: ConfiguratorNameSchema
+  }),
+  z3.strictObject({ ...ParameterBase, kind: z3.literal("material") }),
+  z3.strictObject({ ...ParameterBase, kind: z3.literal("toggle") })
+]);
+var ConfiguratorChoiceListSchema = z3.strictObject({
+  key: ConfiguratorNameSchema,
+  label: LabelSchema,
+  options: z3.array(
+    z3.strictObject({
+      code: ConfiguratorCodeSchema,
+      label: LabelSchema,
+      image: TexturePathSchema.optional()
+    })
+  ).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+});
+var ConfiguratorMaterialSchema = z3.strictObject({
+  code: ConfiguratorCodeSchema,
+  label: LabelSchema,
+  color: z3.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
+  texture: TexturePathSchema.optional(),
+  /** Millimetres one repeat of the texture covers. */
+  textureSize: z3.number().positive().max(1e4).optional(),
+  roughness: z3.number().min(0).max(1).optional(),
+  metalness: z3.number().min(0).max(1).optional(),
+  /** How much of what is behind it shows through: glass in front of a flame. Absent is solid. */
+  opacity: z3.number().min(0.05).max(1).optional(),
+  /** Gives light rather than reflecting it: a flame, a LED. */
+  emissive: z3.boolean().optional(),
+  priceGroup: ConfiguratorCodeSchema.optional()
+});
+var ConditionValueSchema = z3.union([
+  z3.number().finite(),
+  z3.boolean(),
+  ConfiguratorCodeSchema,
+  z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+]);
+var ConfiguratorConditionSchema = z3.strictObject({
+  param: ConfiguratorNameSchema,
+  op: z3.enum(["eq", "neq", "in", "gte", "lte"]),
+  value: ConditionValueSchema
+});
+var ConfiguratorRuleSchema = z3.discriminatedUnion("kind", [
+  /** Show `param` only while `when` holds. */
+  z3.strictObject({
+    kind: z3.literal("visible"),
+    param: ConfiguratorNameSchema,
+    when: ConfiguratorConditionSchema
+  }),
+  /** Narrow a number parameter: `max cabinet_height = total_height - 300`. */
+  z3.strictObject({
+    kind: z3.literal("limit"),
+    param: ConfiguratorNameSchema,
+    bound: z3.enum(["min", "max"]),
+    formula: FormulaSchema
+  }),
+  /** While `when` holds, these codes of a choice or material are not offered. */
+  z3.strictObject({
+    kind: z3.literal("exclude"),
+    param: ConfiguratorNameSchema,
+    codes: z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
+    when: ConfiguratorConditionSchema
+  })
+]);
+var PriceRuleBase = {
+  key: ConfiguratorNameSchema,
+  label: LabelSchema,
+  /** How many times the amount counts, e.g. `compartments`. Absent is once. */
+  multiplier: FormulaSchema.optional()
+};
+var ConfiguratorPriceRuleSchema = z3.discriminatedUnion("kind", [
+  /** The surcharge the model gives the chosen option. */
+  z3.strictObject({
+    ...PriceRuleBase,
+    kind: z3.literal("choice"),
+    param: ConfiguratorNameSchema
+  }),
+  /** The surcharge of the chosen material's price group. */
+  z3.strictObject({
+    ...PriceRuleBase,
+    kind: z3.literal("material"),
+    param: ConfiguratorNameSchema
+  }),
+  /** An amount, counted while a switch is on. */
+  z3.strictObject({
+    ...PriceRuleBase,
+    kind: z3.literal("toggle"),
+    param: ConfiguratorNameSchema,
+    amount: ConfiguratorNameSchema
+  }),
+  /**
+   * A price on measure: `max(0, total_width - 1800) / 1000 * meter_price`.
+   * Reads number parameters (in their unit) and amounts (in cents).
+   */
+  z3.strictObject({
+    key: ConfiguratorNameSchema,
+    label: LabelSchema,
+    kind: z3.literal("formula"),
+    formula: FormulaSchema
+  })
+]);
+var ConfiguratorStructureObjectSchema = z3.strictObject({
+  schemaVersion: z3.literal(1),
+  geometry: GeometryDocumentSchema,
+  tabs: z3.array(z3.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })).min(1).max(CONFIGURATOR_LIMITS.tabs),
+  parameters: z3.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
+  choiceLists: z3.array(ConfiguratorChoiceListSchema).max(CONFIGURATOR_LIMITS.choiceLists),
+  materials: z3.array(ConfiguratorMaterialSchema).max(CONFIGURATOR_LIMITS.materials),
+  priceGroups: z3.array(z3.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })).max(CONFIGURATOR_LIMITS.priceGroups),
+  /** Named amounts a model fills in and price rules read (`meter_price`). */
+  amounts: z3.array(z3.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })).max(CONFIGURATOR_LIMITS.amounts),
+  /**
+   * A list of fixed combinations a model offers, each setting some number
+   * parameters at once: a fireplace and the niche it needs.
+   */
+  presets: z3.strictObject({
+    label: LabelSchema,
+    tab: ConfiguratorNameSchema,
+    sets: z3.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
+    required: z3.boolean()
+  }).optional(),
+  rules: z3.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
+  priceRules: z3.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
+});
+var ConfiguratorStructureSchema = ConfiguratorStructureObjectSchema.superRefine((structure, ctx) => {
+  for (const problem of configuratorStructureProblems(structure)) {
+    ctx.addIssue({
+      code: "custom",
+      path: problem.path,
+      message: problem.code,
+      params: problem.params
+    });
+  }
+});
+function configuratorStructureProblems(structure) {
+  const problems = [];
+  if (jsonByteLength(structure) > CONFIGURATOR_LIMITS.structureBytes) {
+    problems.push(
+      issue([], "configurator.structureTooLarge", {
+        max: CONFIGURATOR_LIMITS.structureBytes
+      })
+    );
+  }
+  const tabs = uniqueKeys(
+    structure.tabs,
+    (tab) => tab.key,
+    ["tabs"],
+    "key",
+    problems
+  );
+  const lists = new Map(
+    structure.choiceLists.map((list) => [
+      list.key,
+      list.options.map((option) => option.code)
+    ])
+  );
+  uniqueKeys(
+    structure.choiceLists,
+    (list) => list.key,
+    ["choiceLists"],
+    "key",
+    problems
+  );
+  structure.choiceLists.forEach(
+    (list, index) => uniqueKeys(
+      list.options,
+      (option) => option.code,
+      ["choiceLists", index, "options"],
+      "code",
+      problems
+    )
+  );
+  const materials = uniqueKeys(
+    structure.materials,
+    (material) => material.code,
+    ["materials"],
+    "code",
+    problems
+  );
+  const groups = uniqueKeys(
+    structure.priceGroups,
+    (group) => group.code,
+    ["priceGroups"],
+    "code",
+    problems
+  );
+  const amounts = uniqueKeys(
+    structure.amounts,
+    (amount) => amount.key,
+    ["amounts"],
+    "key",
+    problems
+  );
+  structure.materials.forEach((material, index) => {
+    if (material.priceGroup && !groups.has(material.priceGroup)) {
+      problems.push(
+        issue(
+          ["materials", index, "priceGroup"],
+          "configurator.unknownPriceGroup",
+          {
+            code: material.priceGroup
+          }
+        )
+      );
+    }
+  });
+  const parameters = new Map(
+    structure.parameters.map((parameter) => [parameter.key, parameter])
+  );
+  uniqueKeys(
+    structure.parameters,
+    (parameter) => parameter.key,
+    ["parameters"],
+    "key",
+    problems
+  );
+  structure.parameters.forEach((parameter, index) => {
+    const path = ["parameters", index];
+    if (!tabs.has(parameter.tab)) {
+      problems.push(
+        issue([...path, "tab"], "configurator.unknownTab", {
+          tab: parameter.tab
+        })
+      );
+    }
+    if (parameter.kind === "number" && parameter.min > parameter.max) {
+      problems.push(
+        issue([...path, "min"], "configurator.minAboveMax", {
+          key: parameter.key
+        })
+      );
+    }
+    if (parameter.kind === "choice" && !lists.has(parameter.list)) {
+      problems.push(
+        issue([...path, "list"], "configurator.unknownList", {
+          list: parameter.list
+        })
+      );
+    }
+  });
+  const numberKeys = new Set(
+    structure.parameters.filter((parameter) => parameter.kind === "number").map((parameter) => parameter.key)
+  );
+  const toggleKeys = new Set(
+    structure.parameters.filter((parameter) => parameter.kind === "toggle").map((parameter) => parameter.key)
+  );
+  const numericScope = /* @__PURE__ */ new Set([...numberKeys, ...toggleKeys]);
+  if (structure.presets) {
+    if (!tabs.has(structure.presets.tab)) {
+      problems.push(
+        issue(["presets", "tab"], "configurator.unknownTab", {
+          tab: structure.presets.tab
+        })
+      );
+    }
+    structure.presets.sets.forEach((key, index) => {
+      if (!numberKeys.has(key)) {
+        problems.push(
+          issue(["presets", "sets", index], "configurator.notANumberParam", {
+            key
+          })
+        );
+      }
+    });
+  }
+  const dependsOn = /* @__PURE__ */ new Map();
+  const addDependency = (from, on) => {
+    const set = dependsOn.get(from) ?? /* @__PURE__ */ new Set();
+    set.add(on);
+    dependsOn.set(from, set);
+  };
+  structure.rules.forEach((rule, index) => {
+    const path = ["rules", index];
+    const target = parameters.get(rule.param);
+    if (!target) {
+      problems.push(
+        issue([...path, "param"], "configurator.unknownParam", {
+          key: rule.param
+        })
+      );
+      return;
+    }
+    if (rule.kind === "limit") {
+      if (target.kind !== "number") {
+        problems.push(
+          issue([...path, "param"], "configurator.notANumberParam", {
+            key: rule.param
+          })
+        );
+      }
+      for (const name of checkFormula(
+        rule.formula,
+        [...path, "formula"],
+        numericScope,
+        problems
+      )) {
+        addDependency(rule.param, name);
+      }
+      return;
+    }
+    if (rule.kind === "exclude") {
+      const codes = codesOf(target, lists, materials);
+      if (!codes) {
+        problems.push(
+          issue([...path, "param"], "configurator.notAChoiceParam", {
+            key: rule.param
+          })
+        );
+      } else {
+        rule.codes.forEach((code, codeIndex) => {
+          if (!codes.has(code)) {
+            problems.push(
+              issue([...path, "codes", codeIndex], "configurator.unknownCode", {
+                code
+              })
+            );
+          }
+        });
+      }
+    }
+    const condition = rule.when;
+    const conditionParam = parameters.get(condition.param);
+    if (!conditionParam) {
+      problems.push(
+        issue([...path, "when", "param"], "configurator.unknownParam", {
+          key: condition.param
+        })
+      );
+      return;
+    }
+    addDependency(rule.param, condition.param);
+    const valueProblem = conditionValueProblem(
+      condition.op,
+      condition.value,
+      conditionParam,
+      lists,
+      materials
+    );
+    if (valueProblem) {
+      problems.push(
+        issue([...path, "when", "value"], valueProblem, {
+          key: condition.param
+        })
+      );
+    }
+  });
+  const cycle = findCycle(dependsOn);
+  if (cycle) {
+    problems.push(
+      issue(["rules"], "configurator.ruleCycle", { cycle: cycle.join(" \u2192 ") })
+    );
+  }
+  const priceRuleKeys = /* @__PURE__ */ new Set();
+  structure.priceRules.forEach((rule, index) => {
+    const path = ["priceRules", index];
+    if (priceRuleKeys.has(rule.key)) {
+      problems.push(
+        issue([...path, "key"], "configurator.duplicateName", {
+          name: rule.key
+        })
+      );
+    }
+    priceRuleKeys.add(rule.key);
+    if (rule.kind === "formula") {
+      checkFormula(
+        rule.formula,
+        [...path, "formula"],
+        /* @__PURE__ */ new Set([...numericScope, ...amounts]),
+        problems
+      );
+      return;
+    }
+    if (rule.multiplier !== void 0) {
+      checkFormula(
+        rule.multiplier,
+        [...path, "multiplier"],
+        numericScope,
+        problems
+      );
+    }
+    const target = parameters.get(rule.param);
+    if (!target || target.kind !== rule.kind) {
+      problems.push(
+        issue([...path, "param"], "configurator.priceRuleParamKind", {
+          key: rule.param,
+          kind: rule.kind
+        })
+      );
+    }
+    if (rule.kind === "toggle" && !amounts.has(rule.amount)) {
+      problems.push(
+        issue([...path, "amount"], "configurator.unknownAmount", {
+          key: rule.amount
+        })
+      );
+    }
+  });
+  const geometryParameters = new Map(
+    structure.parameters.map((parameter) => [
+      parameter.key,
+      parameter.kind === "choice" ? { kind: "choice", codes: lists.get(parameter.list) ?? [] } : { kind: parameter.kind }
+    ])
+  );
+  problems.push(
+    ...geometryDocumentProblems(structure.geometry, {
+      parameters: geometryParameters,
+      materialCodes: materials,
+      path: ["geometry"]
+    })
+  );
+  return problems;
+}
+function uniqueKeys(items, keyOf, path, field, problems) {
+  const seen = /* @__PURE__ */ new Set();
+  items.forEach((item, index) => {
+    const key = keyOf(item);
+    if (seen.has(key)) {
+      problems.push(
+        issue([...path, index, field], "configurator.duplicateName", {
+          name: key
+        })
+      );
+    }
+    seen.add(key);
+  });
+  return seen;
+}
+function checkFormula(formula, path, scope, problems) {
+  const names = formulaNames(formula);
+  if (!names.ok) {
+    problems.push(issue(path, `configurator.${names.code}`));
+    return [];
+  }
+  for (const name of names.names) {
+    if (!scope.has(name)) {
+      problems.push(issue(path, "configurator.unknownName", { name }));
+    }
+  }
+  return names.names;
+}
+function codesOf(parameter, lists, materials) {
+  if (parameter.kind === "choice") {
+    return new Set(lists.get(parameter.list) ?? []);
+  }
+  if (parameter.kind === "material") {
+    return materials;
+  }
+  return null;
+}
+function conditionValueProblem(op, value, parameter, lists, materials) {
+  if (parameter.kind === "number") {
+    return typeof value === "number" && op !== "in" ? null : "configurator.conditionNeedsNumber";
+  }
+  if (parameter.kind === "toggle") {
+    return typeof value === "boolean" && (op === "eq" || op === "neq") ? null : "configurator.conditionNeedsBoolean";
+  }
+  const codes = codesOf(parameter, lists, materials) ?? /* @__PURE__ */ new Set();
+  if (op === "in") {
+    return Array.isArray(value) && value.every((code) => codes.has(code)) ? null : "configurator.conditionUnknownCode";
+  }
+  return (op === "eq" || op === "neq") && typeof value === "string" && codes.has(value) ? null : "configurator.conditionUnknownCode";
+}
+function findCycle(graph) {
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const visit = (node) => {
+    const current = state.get(node);
+    if (current === "done") {
+      return null;
+    }
+    if (current === "visiting") {
+      return [...stack.slice(stack.indexOf(node)), node];
+    }
+    state.set(node, "visiting");
+    stack.push(node);
+    for (const next of graph.get(node) ?? []) {
+      const cycle = visit(next);
+      if (cycle) {
+        return cycle;
+      }
+    }
+    stack.pop();
+    state.set(node, "done");
+    return null;
+  };
+  for (const node of graph.keys()) {
+    const cycle = visit(node);
+    if (cycle) {
+      return cycle;
+    }
+  }
+  return null;
+}
+function parameterResolutionOrder(structure) {
+  const dependsOn = /* @__PURE__ */ new Map();
+  for (const rule of structure.rules) {
+    const set = dependsOn.get(rule.param) ?? /* @__PURE__ */ new Set();
+    if (rule.kind === "limit") {
+      const names = formulaNames(rule.formula);
+      for (const name of names.ok ? names.names : []) {
+        set.add(name);
+      }
+    } else {
+      set.add(rule.when.param);
+    }
+    dependsOn.set(rule.param, set);
+  }
+  const order = [];
+  const placed = /* @__PURE__ */ new Set();
+  const place = (key, trail) => {
+    if (placed.has(key) || trail.has(key)) {
+      return;
+    }
+    trail.add(key);
+    for (const dependency of dependsOn.get(key) ?? []) {
+      place(dependency, trail);
+    }
+    placed.add(key);
+    order.push(key);
+  };
+  for (const parameter of structure.parameters) {
+    place(parameter.key, /* @__PURE__ */ new Set());
+  }
+  return order.filter(
+    (key) => structure.parameters.some((parameter) => parameter.key === key)
+  );
+}
+
+// ../features/product-configurator/src/shared/configurator-value.schema.ts
+import { z as z4 } from "zod";
+var CentsSchema = z4.number().int().min(0).max(1e8);
+var PriceSchema = CentsSchema.nullable();
+var ConfiguratorValueObjectSchema = z4.strictObject({
+  /** Null: the model has no price of its own, every quote is "open". */
+  basePriceCents: PriceSchema,
+  numbers: z4.record(
+    ConfiguratorNameSchema,
+    z4.strictObject({
+      min: z4.number().finite(),
+      max: z4.number().finite(),
+      default: z4.number().finite()
+    })
+  ).default({}),
+  /** Per choice list: the options this model offers, with their surcharge. */
+  choices: z4.record(
+    ConfiguratorNameSchema,
+    z4.strictObject({
+      options: z4.record(
+        ConfiguratorCodeSchema,
+        z4.strictObject({ priceCents: PriceSchema })
+      ),
+      default: ConfiguratorCodeSchema.optional()
+    })
+  ).default({}),
+  /** Per material parameter: the materials this model offers. */
+  materials: z4.record(
+    ConfiguratorNameSchema,
+    z4.strictObject({
+      offered: z4.array(ConfiguratorCodeSchema).max(CONFIGURATOR_LIMITS.materials),
+      default: ConfiguratorCodeSchema.optional()
+    })
+  ).default({}),
+  /** Per switch: whether this model offers it, and how it starts. Absent is offered, off. */
+  toggles: z4.record(
+    ConfiguratorNameSchema,
+    z4.strictObject({ offered: z4.boolean(), default: z4.boolean() })
+  ).default({}),
+  /** The surcharge of each material price group. */
+  priceGroups: z4.record(ConfiguratorCodeSchema, PriceSchema).default({}),
+  /** The amounts the structure names, such as a price per metre. */
+  amounts: z4.record(ConfiguratorNameSchema, PriceSchema).default({}),
+  presets: z4.array(
+    z4.strictObject({
+      code: ConfiguratorCodeSchema,
+      label: z4.string().trim().min(1).max(80),
+      /** A product of the same account this preset stands for, e.g. the fireplace. */
+      productId: z4.string().uuid().nullable(),
+      values: z4.record(ConfiguratorNameSchema, z4.number().finite())
+    })
+  ).max(CONFIGURATOR_LIMITS.presets).default([])
+});
+function emptyConfiguratorValue() {
+  return ConfiguratorValueObjectSchema.parse({ basePriceCents: null });
+}
+
+// ../features/product-configurator/src/shared/resolve-configuration.ts
+var NEUTRAL_SLOT_COLOR = "#b8b4ad";
+var STEP_TOLERANCE = 1e-6;
+function resolveConfiguration(params) {
+  const { structure, value, selection } = params;
+  const issues = [];
+  const parametersByKey = new Map(
+    structure.parameters.map((parameter) => [parameter.key, parameter])
+  );
+  const materialsByCode = new Map(
+    structure.materials.map((material) => [material.code, material])
+  );
+  for (const key of Object.keys(selection.values)) {
+    if (!parametersByKey.has(key)) {
+      issues.push(issue(["values", key], "configurator.unknownParam", { key }));
+    }
+  }
+  const presets = structure.presets ? value.presets.map((preset2) => ({
+    code: preset2.code,
+    label: preset2.label,
+    productId: preset2.productId
+  })) : [];
+  let preset = null;
+  if (selection.preset !== void 0) {
+    preset = presets.find((candidate) => candidate.code === selection.preset) ?? null;
+    if (!preset) {
+      issues.push(
+        issue(["preset"], "configurator.presetNotOffered", {
+          code: selection.preset
+        })
+      );
+    }
+  }
+  if (!preset && structure.presets?.required) {
+    preset = presets[0] ?? null;
+  }
+  const presetValues = preset ? value.presets.find((candidate) => candidate.code === preset?.code)?.values ?? {} : {};
+  const presetSets = new Set(structure.presets?.sets ?? []);
+  const resolved = /* @__PURE__ */ new Map();
+  const numericScope = {};
+  const conditionHolds = (condition) => {
+    const current = resolved.get(condition.param);
+    const actual = current?.visible ? current.value : null;
+    switch (condition.op) {
+      case "eq":
+        return actual === condition.value;
+      case "neq":
+        return actual !== condition.value;
+      case "in":
+        return Array.isArray(condition.value) && condition.value.includes(actual);
+      case "gte":
+        return typeof actual === "number" && actual >= condition.value;
+      case "lte":
+        return typeof actual === "number" && actual <= condition.value;
+    }
+  };
+  for (const key of parameterResolutionOrder(structure)) {
+    const parameter = parametersByKey.get(key);
+    if (!parameter) {
+      continue;
+    }
+    const rules = structure.rules.filter((rule) => rule.param === key);
+    let visible = rules.filter((rule) => rule.kind === "visible").every((rule) => conditionHolds(rule.when));
+    const chosen = selection.values[key];
+    const path = ["values", key];
+    const base = {
+      key,
+      kind: parameter.kind,
+      label: parameter.label,
+      tab: parameter.tab
+    };
+    if (parameter.kind === "number") {
+      const range = value.numbers[key] ?? {
+        min: parameter.min,
+        max: parameter.max,
+        default: parameter.min
+      };
+      let min = range.min;
+      let max = range.max;
+      for (const rule of rules) {
+        if (rule.kind !== "limit") {
+          continue;
+        }
+        const bound = evaluateFormulaSource(rule.formula, numericScope);
+        if (!bound.ok) {
+          issues.push(
+            issue(
+              ["rules", structure.rules.indexOf(rule)],
+              `configurator.${bound.code}`
+            )
+          );
+          continue;
+        }
+        if (rule.bound === "min") {
+          min = Math.max(min, bound.value);
+        } else {
+          max = Math.min(max, bound.value);
+        }
+      }
+      if (min > max) {
+        issues.push(issue(path, "configurator.emptyRange", { key, min, max }));
+        max = min;
+      }
+      const fixedValue = presetSets.has(key) ? presetValues[key] : void 0;
+      let current2 = clamp(range.default, min, max);
+      if (fixedValue !== void 0) {
+        current2 = fixedValue;
+      } else if (visible && chosen !== void 0) {
+        if (typeof chosen !== "number") {
+          issues.push(issue(path, "configurator.expectedNumber", { key }));
+        } else if (chosen < min || chosen > max) {
+          issues.push(
+            issue(path, "configurator.outOfRange", { key, min, max })
+          );
+          current2 = clamp(chosen, min, max);
+        } else if (!onStep(chosen, parameter.step)) {
+          issues.push(
+            issue(path, "configurator.offStep", { key, step: parameter.step })
+          );
+        } else {
+          current2 = chosen;
+        }
+      }
+      numericScope[key] = current2;
+      resolved.set(key, {
+        ...base,
+        visible,
+        value: current2,
+        min,
+        max,
+        step: parameter.step,
+        unit: parameter.unit,
+        fixed: fixedValue !== void 0
+      });
+      continue;
+    }
+    if (parameter.kind === "toggle") {
+      const setting = value.toggles[key] ?? { offered: true, default: false };
+      visible = visible && setting.offered;
+      let current2 = setting.default;
+      if (visible && chosen !== void 0) {
+        if (typeof chosen !== "boolean") {
+          issues.push(issue(path, "configurator.expectedBoolean", { key }));
+        } else {
+          current2 = chosen;
+        }
+      }
+      const on = visible && current2;
+      numericScope[key] = on ? 1 : 0;
+      resolved.set(key, { ...base, visible, value: on });
+      continue;
+    }
+    const excluded = new Set(
+      rules.filter((rule) => rule.kind === "exclude" && conditionHolds(rule.when)).flatMap((rule) => rule.kind === "exclude" ? rule.codes : [])
+    );
+    let options;
+    let preferred;
+    if (parameter.kind === "choice") {
+      const list = structure.choiceLists.find(
+        (candidate) => candidate.key === parameter.list
+      );
+      const offer = value.choices[parameter.list];
+      options = (list?.options ?? []).filter(
+        (option) => offer?.options[option.code] !== void 0 && !excluded.has(option.code)
+      ).map((option) => ({
+        code: option.code,
+        label: option.label,
+        priceCents: offer?.options[option.code]?.priceCents ?? null
+      }));
+      preferred = offer?.default;
+    } else {
+      const offer = value.materials[key];
+      options = (offer?.offered ?? []).map((code) => materialsByCode.get(code)).filter(
+        (material) => material !== void 0
+      ).filter((material) => !excluded.has(material.code)).map((material) => ({
+        code: material.code,
+        label: material.label,
+        priceCents: material.priceGroup ? value.priceGroups[material.priceGroup] ?? null : 0,
+        material
+      }));
+      preferred = offer?.default;
+    }
+    visible = visible && options.length > 0;
+    let current = options.find((option) => option.code === preferred)?.code ?? options[0]?.code ?? null;
+    if (visible && chosen !== void 0) {
+      if (typeof chosen !== "string" || !options.some((option) => option.code === chosen)) {
+        issues.push(
+          issue(path, "configurator.optionNotOffered", {
+            key,
+            code: String(chosen)
+          })
+        );
+      } else {
+        current = chosen;
+      }
+    }
+    resolved.set(key, {
+      ...base,
+      visible,
+      value: visible ? current : null,
+      options
+    });
+  }
+  const parameters = structure.parameters.map((parameter) => resolved.get(parameter.key)).filter(
+    (parameter) => parameter !== void 0
+  );
+  const inputs = {};
+  for (const input of structure.geometry.inputs) {
+    const parameter = resolved.get(input.binding.param);
+    if (!parameter) {
+      continue;
+    }
+    if (parameter.kind === "number") {
+      inputs[input.name] = parameter.value;
+    } else if (parameter.kind === "toggle") {
+      inputs[input.name] = parameter.value === true ? 1 : 0;
+    } else if (parameter.kind === "choice") {
+      inputs[input.name] = typeof parameter.value === "string" ? input.binding.map?.[parameter.value] ?? 0 : 0;
+    }
+  }
+  const slots = {};
+  for (const slot of structure.geometry.slots) {
+    let material = null;
+    if (slot.param) {
+      const parameter = resolved.get(slot.param);
+      material = parameter?.options?.find((option) => option.code === parameter.value)?.material ?? null;
+    } else if (slot.material) {
+      material = materialsByCode.get(slot.material) ?? null;
+    }
+    slots[slot.name] = {
+      color: material?.color ?? slot.color ?? NEUTRAL_SLOT_COLOR,
+      material
+    };
+  }
+  const normalised = { values: {} };
+  for (const parameter of parameters) {
+    if (parameter.visible && !parameter.fixed && parameter.value !== null) {
+      normalised.values[parameter.key] = parameter.value;
+    }
+  }
+  if (preset) {
+    normalised.preset = preset.code;
+  }
+  return {
+    configuration: {
+      parameters,
+      byKey: Object.fromEntries(resolved),
+      presets,
+      preset,
+      inputs,
+      slots,
+      selection: normalised
+    },
+    issues
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function onStep(value, step) {
+  const ratio = value / step;
+  return Math.abs(ratio - Math.round(ratio)) < STEP_TOLERANCE;
+}
+
+// ../features/product-configurator/src/shared/expand-geometry.ts
+function expandGeometry(document, inputs) {
+  const issues = [];
+  const parts = [];
+  const baseScope = { ...document.constants };
+  for (const input of document.inputs) {
+    const number = inputs[input.name];
+    if (number === void 0 || !Number.isFinite(number)) {
+      issues.push(
+        issue(["inputs", input.name], "configurator.inputMissing", {
+          name: input.name
+        })
+      );
+      continue;
+    }
+    baseScope[input.name] = number;
+  }
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  const evaluate = (formula, scope, path) => {
+    const result = evaluateFormulaSource(formula, scope);
+    if (!result.ok) {
+      issues.push(
+        result.code === "formula_unknown_name" ? issue(path, "configurator.unknownName", { name: result.name }) : issue(path, `configurator.${result.code}`)
+      );
+      return null;
+    }
+    return result.value;
+  };
+  const walk = (nodes, scope, path, keySuffix, depth) => {
+    for (const node of nodes) {
+      if (issues.length > 0) {
+        return;
+      }
+      const nodePath = [...path, node.id];
+      if (node.visible !== void 0) {
+        const visible = evaluate(node.visible, scope, [...nodePath, "visible"]);
+        if (visible === null || visible <= 0) {
+          continue;
+        }
+      }
+      if (node.type === "repeat") {
+        if (depth + 1 > CONFIGURATOR_LIMITS.repeatDepth) {
+          issues.push(
+            issue(nodePath, "configurator.repeatTooDeep", {
+              max: CONFIGURATOR_LIMITS.repeatDepth
+            })
+          );
+          return;
+        }
+        const count = evaluate(node.count, scope, [...nodePath, "count"]);
+        if (count === null) {
+          return;
+        }
+        if (!Number.isInteger(count) || count < 0 || count > CONFIGURATOR_LIMITS.repeatCount) {
+          issues.push(
+            issue([...nodePath, "count"], "configurator.repeatCountInvalid", {
+              count,
+              max: CONFIGURATOR_LIMITS.repeatCount
+            })
+          );
+          return;
+        }
+        const index = node.index ?? "i";
+        for (let step = 0; step < count; step += 1) {
+          walk(
+            node.children,
+            { ...scope, [index]: step },
+            [...nodePath, step],
+            `${keySuffix}[${step}]`,
+            depth + 1
+          );
+        }
+        continue;
+      }
+      const size = node.size.map(
+        (formula, axis) => evaluate(formula, scope, [...nodePath, "size", axis])
+      );
+      const at = node.at.map(
+        (formula, axis) => evaluate(formula, scope, [...nodePath, "at", axis])
+      );
+      if (size.includes(null) || at.includes(null)) {
+        return;
+      }
+      const negative = size.findIndex((measure) => measure < 0);
+      if (negative >= 0) {
+        issues.push(
+          issue(
+            [...nodePath, "size", negative],
+            "configurator.negativeMeasure",
+            {
+              value: size[negative]
+            }
+          )
+        );
+        return;
+      }
+      const params = {};
+      for (const [key, formula] of Object.entries(node.params ?? {})) {
+        const number = evaluate(formula, scope, [...nodePath, "params", key]);
+        if (number === null) {
+          return;
+        }
+        params[key] = number;
+      }
+      parts.push({
+        key: `${node.id}${keySuffix}`,
+        id: node.id,
+        type: node.type,
+        slot: node.slot,
+        size,
+        at,
+        params
+      });
+      if (parts.length > CONFIGURATOR_LIMITS.expandedParts) {
+        issues.push(
+          issue(["root"], "configurator.tooManyParts", {
+            max: CONFIGURATOR_LIMITS.expandedParts
+          })
+        );
+        return;
+      }
+    }
+  };
+  walk(document.root, baseScope, ["root"], "", 0);
+  const dimensions = [];
+  for (const annotation of document.annotations) {
+    const path = ["annotations", annotation.id];
+    const from = evaluate(annotation.from, baseScope, [...path, "from"]);
+    const to = evaluate(annotation.to, baseScope, [...path, "to"]);
+    const at = evaluate(annotation.at, baseScope, [...path, "at"]);
+    if (from === null || to === null || at === null) {
+      continue;
+    }
+    dimensions.push({
+      id: annotation.id,
+      axis: annotation.axis,
+      from,
+      to,
+      at,
+      label: annotation.label ?? null,
+      length: Math.abs(to - from)
+    });
+  }
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  return { ok: true, geometry: { parts, dimensions, bounds: boundsOf(parts) } };
+}
+function boundsOf(parts) {
+  if (parts.length === 0) {
+    return { min: [0, 0, 0], max: [0, 0, 0] };
+  }
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const part of parts) {
+    for (let axis = 0; axis < 3; axis += 1) {
+      min[axis] = Math.min(min[axis], part.at[axis]);
+      max[axis] = Math.max(
+        max[axis],
+        part.at[axis] + part.size[axis]
+      );
+    }
+  }
+  return { min, max };
+}
+
+// src/configurator-tools.ts
+var CONFIGURATOR = 'A "configurator" field holds a 3D product configurator. Its structure has "geometry" (the shape document: "inputs" bound to parameters, "constants", material "slots", a "root" tree of building blocks and "annotations" for dimension lines), "parameters", "choiceLists", "materials", "priceGroups", "amounts", optional "presets", "rules" and "priceRules". Building blocks: box, rounded_top_box (params.radius), stadium_prism, arc_panel (params.thickness, params.mirror), led_strip, niche_panel (params.niche_x, niche_y, niche_width, niche_height) and repeat (count, children, index i or j). Every measure is millimetres; "at" is the minimum corner, x left to right, y bottom to top, z from the wall into the room; "size" is width, height, depth. A measure is a number or a formula with + - * / ( ) and min, max, floor, ceil, round, abs over the shape\u2019s inputs, constants and the repeat index. This server can check such a document but never save it: a reseller uploads it in the object builder.';
+var documentInput = z5.string().min(2).max(2e5).describe(
+  'The JSON text of a whole configurator structure (it has "schemaVersion"), or of a shape document alone (it has "root").'
+);
+function registerConfiguratorTools(server, client) {
+  server.registerTool(
+    "check_configurator_shape",
+    {
+      title: "Check a configurator structure or shape document",
+      description: "Checks a configurator structure or a shape document exactly as the object builder will when a reseller uploads it: the outline, every name a formula reads, bindings, cycles in the rules and the limits. A whole structure is also expanded at its smallest measures, so a part that would come out negative is named. Answers with every problem and where it is, or that the document is sound. " + CONFIGURATOR,
+      inputSchema: { document: documentInput },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    ({ document }) => {
+      const problems = checkDocument(document);
+      return answer(
+        problems.length === 0 ? "The document is sound. A reseller can upload it in the object builder." : [
+          `${problems.length} problem(s):`,
+          ...problems.map(describeIssue)
+        ].join("\n"),
+        { problems }
+      );
+    }
+  );
+  server.registerTool(
+    "read_configurator",
+    {
+      title: "Read the configurator of a product",
+      description: "The configurator field of one product as its page receives it: the structure (texture paths already URLs), the model\u2019s value (ranges, offered options, amounts, presets), the tax a quote uses and the two hashes a request must send back. Useful to draft a new shape from an existing one. " + CONFIGURATOR,
+      inputSchema: {
+        slugOrId: z5.string().min(1).max(200).describe("The address (slug) or the id of the product."),
+        field: z5.string().min(1).max(64).describe("The slug of the configurator field.")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ slugOrId: slugOrId2, field }) => {
+      try {
+        const product = await client.getProduct(slugOrId2);
+        const value = product?.fields[field];
+        if (!product) {
+          return answer(`No product "${slugOrId2}" on this account.`, null);
+        }
+        if (!value || typeof value !== "object" || !("structure" in value)) {
+          return answer(
+            `The product has no public configurator under "${field}".`,
+            null
+          );
+        }
+        return answer(`The configurator "${field}" of ${product.name}.`, value);
+      } catch (error) {
+        return refusal(error);
+      }
+    }
+  );
+}
+function checkDocument(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [{ path: [], code: "configurator.notJson" }];
+  }
+  if (isRecord(parsed) && "schemaVersion" in parsed) {
+    const structure = ConfiguratorStructureSchema.safeParse(parsed);
+    if (!structure.success) {
+      return structure.error.issues.map(toIssue);
+    }
+    const { configuration } = resolveConfiguration({
+      structure: structure.data,
+      value: emptyConfiguratorValue(),
+      selection: { values: {} }
+    });
+    const expanded = expandGeometry(
+      structure.data.geometry,
+      configuration.inputs
+    );
+    return expanded.ok ? [] : expanded.issues.map((problem) => ({
+      ...problem,
+      path: ["geometry", ...problem.path]
+    }));
+  }
+  const geometry = GeometryDocumentSchema.safeParse(parsed);
+  if (!geometry.success) {
+    return geometry.error.issues.map(toIssue);
+  }
+  return geometryDocumentProblems(geometry.data);
+}
+function toIssue(problem) {
+  const params = problem.params;
+  return {
+    path: problem.path.map(
+      (part) => typeof part === "number" ? part : String(part)
+    ),
+    code: problem.message,
+    ...params ? { params } : {}
+  };
+}
+function describeIssue(problem) {
+  const where = formatIssuePath(problem.path) || "(the document)";
+  const params = problem.params ? ` (${Object.entries(problem.params).map(([key, value]) => `${key}: ${value}`).join(", ")})` : "";
+  return `- ${where}: ${problem.code}${params}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/placement-tools.ts
+import { z as z6 } from "zod";
 var REACT_HINT = "On a React or Next.js site, prefer the components in `@solumflow-app/crm-client/react` (CrmForm, CrmBooking, CrmChatWidget, CrmSiteTracking) over pasting HTML.";
 var page = {
-  cursor: z2.string().optional().describe("The nextCursor of the previous page; leave out for the first."),
-  limit: z2.number().int().min(1).max(100).optional()
+  cursor: z6.string().optional().describe("The nextCursor of the previous page; leave out for the first."),
+  limit: z6.number().int().min(1).max(100).optional()
 };
-var origin = z2.string().regex(/^https?:\/\/[a-zA-Z0-9.-]+(:[0-9]{1,5})?$/).describe("Scheme, host and optional port; no path: https://www.example.com");
+var origin = z6.string().regex(/^https?:\/\/[a-zA-Z0-9.-]+(:[0-9]{1,5})?$/).describe("Scheme, host and optional port; no path: https://www.example.com");
 function registerPlacementTools(server, client) {
   server.registerTool(
     "list_forms",
@@ -140,7 +1995,7 @@ function registerPlacementTools(server, client) {
     "list_booking_pages",
     {
       title: "List booking pages",
-      description: "Every page a visitor can book on: the services overview, each category and service, and each appointment calendar. Each has a link; services, categories and the overview also have an embed snippet (an iframe plus a sizing script). A calendar has no embed: link to it. " + REACT_HINT,
+      description: "Every page a visitor can book on: the services overview, each category and service, and each appointment calendar. Each has a link and an embed snippet (an iframe plus a sizing script); a paid calendar embedded this way opens its payment in a tab of its own. " + REACT_HINT,
       inputSchema: {},
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -185,13 +2040,13 @@ function registerPlacementTools(server, client) {
       title: "Make or change a chat widget",
       description: "Makes the chat widget at this address when there is none, or changes it. Sets its name, whether it is live, and which sites it may run on. How it looks and what it says is done in the app\u2019s builder. Sites are added and removed, never replaced. Careful: an empty list means ANY site, so adding the first origin narrows the widget to that site only, and removing an origin takes the chat off a site that may be live.",
       inputSchema: {
-        slug: z2.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
+        slug: z6.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
           'The widget\u2019s address on this account, such as "website-chat".'
         ),
-        name: z2.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
-        status: z2.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
-        addAllowedOrigins: z2.array(origin).max(20).optional(),
-        removeAllowedOrigins: z2.array(origin).max(20).optional()
+        name: z6.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
+        status: z6.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
+        addAllowedOrigins: z6.array(origin).max(20).optional(),
+        removeAllowedOrigins: z6.array(origin).max(20).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -239,9 +2094,9 @@ ${describeChatWidget(widget)}`,
       title: "Set up or change the tracking script",
       description: "Sets website tracking up when it is not there, adds or removes the hosts it counts visits from, and changes the consent it waits for. An empty list of hosts counts nothing, so add the host of every site the script is placed on. Hosts are added and removed, never replaced.",
       inputSchema: {
-        addAllowedHosts: z2.array(z2.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
-        removeAllowedHosts: z2.array(z2.string()).max(20).optional(),
-        consentSignal: z2.enum([
+        addAllowedHosts: z6.array(z6.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
+        removeAllowedHosts: z6.array(z6.string()).max(20).optional(),
+        consentSignal: z6.enum([
           "ad_storage",
           "analytics_storage",
           "personalization_storage",
@@ -282,7 +2137,7 @@ function describeBookingPage(page2) {
   return [
     `**${page2.name}** (${page2.kind}${page2.id ? `, id ${page2.id}` : ""})`,
     `Link: ${page2.url}`,
-    page2.embed ? codeBlock(page2.embed) : "No embed: link to it."
+    codeBlock(page2.embed)
   ].join("\n");
 }
 function describeChatWidget(widget) {
@@ -338,7 +2193,7 @@ async function main() {
   }
   const server = new McpServer({
     name: "crm-mcp-server",
-    version: "0.2.0"
+    version: "0.3.0"
   });
   const client = createClient({
     apiKey: config.apiKey,
@@ -346,6 +2201,7 @@ async function main() {
   });
   registerPlacementTools(server, client);
   registerCatalogTools(server, client);
+  registerConfiguratorTools(server, client);
   await server.connect(new StdioServerTransport());
 }
 main().catch((error) => {