@solumflow-app/crm-mcp-server 0.12.0 → 0.13.0

package/dist/index.js

@@ -6,16 +6,203 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { createClient } from "@solumflow-app/crm-client";
 
 // package.json
-var version = "0.12.0";
+var version = "0.13.0";
+
+// src/calendar-setup-tools.ts
+import { z as z2 } from "zod";
+
+// src/tool-answers.ts
+import { CrmApiError } from "@solumflow-app/crm-client";
+import { z } from "zod";
+function answer(text2, data) {
+  return {
+    content: [{ type: "text", text: text2 }],
+    structuredContent: { result: data }
+  };
+}
+function refusal(error, scope) {
+  if (!(error instanceof CrmApiError)) {
+    throw error;
+  }
+  const lines = [`${error.code}: ${error.message}`];
+  const next = error.code === "forbidden" ? `The key may not do this. It needs to be a secret key with the scope "${scope}".` : NEXT_STEP[error.code];
+  if (next) {
+    lines.push(next);
+  }
+  for (const field of error.fields) {
+    lines.push(`- ${field.path}: ${field.message}`);
+  }
+  return {
+    isError: true,
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+var NEXT_STEP = {
+  unauthorized: "The key is not recognised or was revoked. Ask the account owner for a new secret key.",
+  feature_unavailable: "The module this needs is switched off for the account. Ask somebody to switch it on in the app.",
+  rate_limited: "Too many requests: 120 a minute per key, 600 per account, and 5 MB of bodies a day per key. Wait the seconds the answer names and try again.",
+  internal_error: "Something went wrong in the app. Trying again is safe.",
+  limit_reached: "The reseller has as many customer accounts as its plan allows. The platform owner raises that, not another try."
+};
+function codeBlock(snippet) {
+  return `\`\`\`html
+${snippet}
+\`\`\``;
+}
+var page = {
+  cursor: z.string().optional().describe("The nextCursor of the previous page; leave out for the first."),
+  limit: z.number().int().min(1).max(100).optional()
+};
+function more(nextCursor) {
+  return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
+}
+function money(cents3, currency2) {
+  return `${(cents3 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
+}
+function fieldsNotOnPageNote(slugs) {
+  if (!slugs?.length) {
+    return "";
+  }
+  const count = slugs.length === 1 ? "1 public field has" : `${slugs.length} public fields have`;
+  return ` ${count} a value but ${slugs.length === 1 ? "is" : "are"} not on this product's page: ${slugs.join(", ")}; send them in publicFields to show them.`;
+}
+
+// src/calendar-setup-tools.ts
+var slug = z2.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe('Lowercase letters, digits and dashes, e.g. "kennismaking".');
+var time = z2.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).describe("HH:MM on the calendar\u2019s own clock.");
+var NEVER_APPOINTMENTS = "It never makes or moves an appointment: that mails a customer, and stays in the app. list_booking_pages shows the result.";
+function registerCalendarSetupTools(server, client) {
+  server.registerTool(
+    "upsert_calendar",
+    {
+      title: "Make or change a calendar",
+      description: `A calendar by its address (slug): "event" for meetings with one host, "round_robin" for whoever of the hosts is free, or "services" for the account\u2019s own services calendar, which is changed and never made. A new calendar takes the defaults for what is left out; one that exists keeps it. A new calendar naming no hosts is taken by the account\u2019s owner. ${NEVER_APPOINTMENTS}`,
+      inputSchema: {
+        slug,
+        name: z2.string().min(1).max(120),
+        type: z2.enum(["event", "round_robin", "services"]).optional(),
+        description: z2.string().max(5e3).nullable().optional(),
+        durationMinutes: z2.number().int().min(1).max(1440).optional(),
+        isActive: z2.boolean().optional(),
+        slotIntervalMinutes: z2.number().int().min(1).max(1440).optional(),
+        minNoticeMinutes: z2.number().int().min(0).optional(),
+        bookingHorizonDays: z2.number().int().min(1).max(730).optional(),
+        bufferBeforeMinutes: z2.number().int().min(0).max(1440).optional(),
+        bufferAfterMinutes: z2.number().int().min(0).max(1440).optional(),
+        maxPerDay: z2.number().int().min(1).nullable().optional(),
+        timezoneMode: z2.enum(["visitor", "fixed"]).optional(),
+        timezone: z2.string().optional().describe("An IANA zone, e.g. Europe/Amsterdam."),
+        hostUserIds: z2.array(z2.string().uuid()).min(1).max(50).optional()
+      },
+      annotations: { idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const result = await client.upsertCalendar(input);
+        return answer(
+          `${result.created ? "Made" : "Changed"}: ${describeCalendar(result.calendar)}`,
+          result
+        );
+      } catch (error) {
+        return refusal(error, "calendar:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "set_calendar_availability",
+    {
+      title: "Set a calendar\u2019s opening hours",
+      description: "The hours a calendar can be booked: weekly rules (weekday 0 is Sunday) and exceptions per date (closed, or other hours). Each list sent replaces the one there; one left out is kept. For the services calendar these are the hours its services can be booked.",
+      inputSchema: {
+        slug,
+        rules: z2.array(
+          z2.object({
+            weekday: z2.number().int().min(0).max(6),
+            startsTime: time,
+            endsTime: time,
+            userId: z2.string().uuid().nullable().optional()
+          })
+        ).max(200).optional(),
+        overrides: z2.array(
+          z2.object({
+            date: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+            isUnavailable: z2.boolean().optional(),
+            startsTime: time.nullable().optional(),
+            endsTime: time.nullable().optional(),
+            userId: z2.string().uuid().nullable().optional()
+          })
+        ).max(365).optional()
+      },
+      annotations: { idempotentHint: true }
+    },
+    async ({ slug: calendarSlug, rules, overrides }) => {
+      try {
+        const result = await client.setCalendarAvailability(calendarSlug, {
+          rules,
+          overrides
+        });
+        const parts = [
+          rules ? `${rules.length} weekly rule(s)` : "",
+          overrides ? `${overrides.length} exception(s)` : ""
+        ].filter(Boolean);
+        return answer(
+          `Hours of "${result.slug}" saved: ${parts.join(" and ")}.`,
+          result
+        );
+      } catch (error) {
+        return refusal(error, "calendar:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_services",
+    {
+      title: "Make or change bookable services",
+      description: `Up to fifty services the services calendar offers, each by its address (slug): name, length in minutes, price in cents, group (category) and whether the booking page lists it. A service nobody performs is given the account\u2019s owner, so it has free times at once. Paid on the spot: paying in advance needs the account\u2019s own Stripe connection, set in the app. ${NEVER_APPOINTMENTS}`,
+      inputSchema: {
+        services: z2.array(
+          z2.object({
+            slug: z2.string().min(1).max(120).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+            name: z2.string().min(1).max(200),
+            durationMinutes: z2.number().int().min(5).max(1440),
+            priceCents: z2.number().int().min(0).optional(),
+            description: z2.string().max(5e3).nullable().optional(),
+            active: z2.boolean().optional(),
+            visibility: z2.enum(["public", "private"]).optional(),
+            category: z2.string().min(1).max(120).nullable().optional()
+          })
+        ).min(1).max(50)
+      },
+      annotations: { idempotentHint: true }
+    },
+    async ({ services }) => {
+      try {
+        const result = await client.upsertServices(services);
+        return answer(result.map(describeService).join("\n"), result);
+      } catch (error) {
+        return refusal(error, "calendar:manage");
+      }
+    }
+  );
+}
+function describeCalendar(calendar) {
+  const state = calendar.isActive ? "" : ", switched off";
+  return `${calendar.name} (${calendar.slug}, ${calendar.type}), ${calendar.durationMinutes} min, ${calendar.timezone}${state}`;
+}
+function describeService(service) {
+  const verb = service.created ? "made" : "changed";
+  const price = service.priceCents ? `price ${(service.priceCents / 100).toFixed(2)}` : "free";
+  return `- ${service.name} (${service.slug}): ${service.durationMinutes} min, ${price}, ${service.visibility}${service.active ? "" : ", inactive"} -- ${verb}`;
+}
 
 // src/catalog-migration-tools.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../features/crm-invoicing/src/schema/catalog-api.schema.ts
-import * as z5 from "zod";
+import * as z7 from "zod";
 
 // ../features/crm-invoicing/src/shared/product-surcharge-options-schema.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // ../features/product-configurator/src/shared/configurator-limits.ts
 var CONFIGURATOR_LIMITS = {
@@ -385,16 +572,16 @@ function evaluateFormulaSource(source, scope) {
 }
 
 // ../features/product-configurator/src/shared/geometry-document.schema.ts
-import { z } from "zod";
+import { z as z3 } 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 = z.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
-var ConfiguratorCodeSchema = z.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
-var FormulaSchema = z.union([
-  z.number().finite(),
-  z.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
+var ConfiguratorNameSchema = z3.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
+var ConfiguratorCodeSchema = z3.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
+var FormulaSchema = z3.union([
+  z3.number().finite(),
+  z3.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
 ]);
-var Vector3Schema = z.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
+var Vector3Schema = z3.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
 var PRIMITIVE_TYPES = [
   "box",
   "rounded_top_box",
@@ -436,10 +623,10 @@ var CONFIGURATOR_FOLLOWS_PRESET = "preset";
 var MOTION_GROUP_PATTERN = /^[a-z](?:[a-z0-9_]|\{[ij]\}){0,39}$/;
 var MOTION_KINDS = ["hinge", "slide"];
 var MOTION_EDGES = ["bottom", "top", "left", "right"];
-var GeometryMotionSchema = z.strictObject({
-  group: z.string().regex(MOTION_GROUP_PATTERN, "configurator.invalidName"),
-  kind: z.enum(MOTION_KINDS),
-  edge: z.enum(MOTION_EDGES).optional(),
+var GeometryMotionSchema = z3.strictObject({
+  group: z3.string().regex(MOTION_GROUP_PATTERN, "configurator.invalidName"),
+  kind: z3.enum(MOTION_KINDS),
+  edge: z3.enum(MOTION_EDGES).optional(),
   angle: FormulaSchema.optional(),
   distance: FormulaSchema.optional()
 });
@@ -449,94 +636,94 @@ var PrimitiveNodeFields = {
   size: Vector3Schema,
   at: Vector3Schema,
   visible: FormulaSchema.optional(),
-  params: z.record(ConfiguratorNameSchema, FormulaSchema).optional(),
+  params: z3.record(ConfiguratorNameSchema, FormulaSchema).optional(),
   motion: GeometryMotionSchema.optional()
 };
-var PrimitiveNodeSchema = z.strictObject({
+var PrimitiveNodeSchema = z3.strictObject({
   ...PrimitiveNodeFields,
-  type: z.enum(PRIMITIVE_TYPES).exclude(["model"])
+  type: z3.enum(PRIMITIVE_TYPES).exclude(["model"])
 });
-var ModelPathSchema = z.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
-var ServedFileUrlSchema = z.url({ protocol: /^https?$/ });
+var ModelPathSchema = z3.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
+var ServedFileUrlSchema = z3.url({ protocol: /^https?$/ });
 function geometryNodeSchema(modelFile) {
-  const ModelNodeSchema = z.strictObject({
+  const ModelNodeSchema = z3.strictObject({
     ...PrimitiveNodeFields,
-    type: z.literal("model"),
+    type: z3.literal("model"),
     model: modelFile
   });
-  const ModelPerChoiceNodeSchema = z.strictObject({
+  const ModelPerChoiceNodeSchema = z3.strictObject({
     ...PrimitiveNodeFields,
-    type: z.literal("model"),
+    type: z3.literal("model"),
     follows: ConfiguratorNameSchema,
-    models: z.record(ConfiguratorCodeSchema, modelFile).refine(
+    models: z3.record(ConfiguratorCodeSchema, modelFile).refine(
       (models) => Object.keys(models).length <= CONFIGURATOR_LIMITS.presets,
       { message: "configurator.tooMany" }
     )
   });
-  const node = z.lazy(
-    () => z.union([
+  const node = z3.lazy(
+    () => z3.union([
       PrimitiveNodeSchema,
       ModelNodeSchema,
       ModelPerChoiceNodeSchema,
-      z.strictObject({
+      z3.strictObject({
         id: ConfiguratorNameSchema,
-        type: z.literal("repeat"),
+        type: z3.literal("repeat"),
         count: FormulaSchema,
-        index: z.enum(["i", "j"]).optional(),
+        index: z3.enum(["i", "j"]).optional(),
         visible: FormulaSchema.optional(),
-        children: z.array(node).min(1)
+        children: z3.array(node).min(1)
       })
     ])
   );
   return node;
 }
 var GeometryNodeSchema = geometryNodeSchema(ModelPathSchema);
-var GeometryBindingSchema = z.strictObject({
+var GeometryBindingSchema = z3.strictObject({
   param: ConfiguratorNameSchema,
-  map: z.record(ConfiguratorCodeSchema, z.number().finite()).optional()
+  map: z3.record(ConfiguratorCodeSchema, z3.number().finite()).optional()
 });
-var GeometryInputSchema = z.strictObject({
+var GeometryInputSchema = z3.strictObject({
   name: ConfiguratorNameSchema,
   binding: GeometryBindingSchema
 });
-var GeometrySlotSchema = z.strictObject({
+var GeometrySlotSchema = z3.strictObject({
   name: ConfiguratorNameSchema,
   param: ConfiguratorNameSchema.optional(),
   material: ConfiguratorCodeSchema.optional(),
-  color: z.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional(),
+  color: z3.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional(),
   /**
    * Which way the grain of a picture runs on this part: `horizontal` (the
    * default) as the picture is drawn, `vertical` turned a quarter. It belongs
    * to the part, not the material: the same oak lies on a cabinet and stands
    * on a tall wall panel.
    */
-  grain: z.enum(["horizontal", "vertical"]).optional()
+  grain: z3.enum(["horizontal", "vertical"]).optional()
 });
-var GeometryAnnotationSchema = z.strictObject({
+var GeometryAnnotationSchema = z3.strictObject({
   id: ConfiguratorNameSchema,
-  axis: z.enum(["x", "y"]),
+  axis: z3.enum(["x", "y"]),
   from: FormulaSchema,
   to: FormulaSchema,
   at: FormulaSchema,
-  label: z.string().trim().min(1).max(80).optional()
+  label: z3.string().trim().min(1).max(80).optional()
 });
 function geometryDocumentSchema(modelFile) {
-  return z.strictObject({
+  return z3.strictObject({
     /** Rises with every new upload, so a product page can say which one it shows. */
-    version: z.number().int().min(1),
+    version: z3.number().int().min(1),
     /** The starter document this one was copied from, for information only. */
-    startedFrom: z.string().trim().max(80).optional(),
-    inputs: z.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
-    constants: z.record(ConfiguratorNameSchema, z.number().finite()),
-    slots: z.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
-    root: z.array(geometryNodeSchema(modelFile)).min(1),
-    camera: z.strictObject({
+    startedFrom: z3.string().trim().max(80).optional(),
+    inputs: z3.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
+    constants: z3.record(ConfiguratorNameSchema, z3.number().finite()),
+    slots: z3.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
+    root: z3.array(geometryNodeSchema(modelFile)).min(1),
+    camera: z3.strictObject({
       /** Degrees around the vertical axis, 0 is straight on. */
-      azimuth: z.number().min(-90).max(90),
+      azimuth: z3.number().min(-90).max(90),
       /** Degrees above the horizon. */
-      elevation: z.number().min(-10).max(80)
+      elevation: z3.number().min(-10).max(80)
     }).optional(),
-    annotations: z.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+    annotations: z3.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
   });
 }
 var GeometryDocumentSchema = geometryDocumentSchema(ModelPathSchema);
@@ -872,7 +1059,7 @@ function followProblems(follows, path, context) {
 }
 
 // ../features/product-configurator/src/shared/configurator-structure.schema.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // ../features/product-configurator/src/shared/room-palette.ts
 var ROOM_WALL_PALETTE = [
@@ -901,104 +1088,104 @@ var ROOM_FLOOR_PALETTE = [
 ];
 
 // ../features/product-configurator/src/shared/configurator-structure.schema.ts
-var LabelSchema = z2.string().trim().min(1).max(80);
+var LabelSchema = z4.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 = z2.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
+var TexturePathSchema = z4.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
 var ParameterBase = {
   key: ConfiguratorNameSchema,
   label: LabelSchema,
   tab: ConfiguratorNameSchema
 };
-var ConfiguratorParameterSchema = z2.discriminatedUnion("kind", [
-  z2.strictObject({
+var ConfiguratorParameterSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({
     ...ParameterBase,
-    kind: z2.literal("number"),
+    kind: z4.literal("number"),
     /** `mm` is a measure, `count` a number of things (compartments). */
-    unit: z2.enum(["mm", "count"]),
-    step: z2.number().positive().finite(),
+    unit: z4.enum(["mm", "count"]),
+    step: z4.number().positive().finite(),
     /** The widest range any model may offer; a model narrows it in its value. */
-    min: z2.number().finite(),
-    max: z2.number().finite()
+    min: z4.number().finite(),
+    max: z4.number().finite()
   }),
-  z2.strictObject({
+  z4.strictObject({
     ...ParameterBase,
-    kind: z2.literal("choice"),
+    kind: z4.literal("choice"),
     list: ConfiguratorNameSchema
   }),
-  z2.strictObject({ ...ParameterBase, kind: z2.literal("material") }),
-  z2.strictObject({ ...ParameterBase, kind: z2.literal("toggle") })
+  z4.strictObject({ ...ParameterBase, kind: z4.literal("material") }),
+  z4.strictObject({ ...ParameterBase, kind: z4.literal("toggle") })
 ]);
-var choiceListSchema = (picture) => z2.strictObject({
+var choiceListSchema = (picture) => z4.strictObject({
   key: ConfiguratorNameSchema,
   label: LabelSchema,
-  options: z2.array(
-    z2.strictObject({
+  options: z4.array(
+    z4.strictObject({
       code: ConfiguratorCodeSchema,
       label: LabelSchema,
       image: picture.optional()
     })
   ).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 });
-var materialSchema = (picture) => z2.strictObject({
+var materialSchema = (picture) => z4.strictObject({
   code: ConfiguratorCodeSchema,
   label: LabelSchema,
-  color: z2.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
+  color: z4.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
   texture: picture.optional(),
   /** Millimetres one repeat of the texture covers; the two maps below share it. */
-  textureSize: z2.number().positive().max(1e4).optional(),
+  textureSize: z4.number().positive().max(1e4).optional(),
   /** Relief that moves with the light: a tangent-space normal map. */
   normalMap: picture.optional(),
   /** How deep the relief reads; 1 is the map as drawn. */
-  normalScale: z2.number().min(0).max(3).optional(),
+  normalScale: z4.number().min(0).max(3).optional(),
   /** Where the surface is matte and where it shines (the green channel), times `roughness`. */
   roughnessMap: picture.optional(),
-  roughness: z2.number().min(0).max(1).optional(),
-  metalness: z2.number().min(0).max(1).optional(),
+  roughness: z4.number().min(0).max(1).optional(),
+  metalness: z4.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: z2.number().min(0.05).max(1).optional(),
+  opacity: z4.number().min(0.05).max(1).optional(),
   /** Gives light rather than reflecting it: a flame, a LED. */
-  emissive: z2.boolean().optional(),
+  emissive: z4.boolean().optional(),
   /**
    * The colour temperature of a light, in kelvin: a LED strip sold as
    * 3000 K glows and lights in that colour rather than in `color`, which
    * stays the swatch's fallback. A strip that can do several (2700-6500 K)
    * names the one to show: 4000 K.
    */
-  kelvin: z2.number().int().min(1500).max(1e4).optional(),
+  kelvin: z4.number().int().min(1500).max(1e4).optional(),
   priceGroup: ConfiguratorCodeSchema.optional()
 });
 var ConfiguratorChoiceListSchema = choiceListSchema(TexturePathSchema);
 var ConfiguratorMaterialSchema = materialSchema(TexturePathSchema);
-var ConditionValueSchema = z2.union([
-  z2.number().finite(),
-  z2.boolean(),
+var ConditionValueSchema = z4.union([
+  z4.number().finite(),
+  z4.boolean(),
   ConfiguratorCodeSchema,
-  z2.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+  z4.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 ]);
-var ConfiguratorConditionSchema = z2.strictObject({
+var ConfiguratorConditionSchema = z4.strictObject({
   param: ConfiguratorNameSchema,
-  op: z2.enum(["eq", "neq", "in", "gte", "lte"]),
+  op: z4.enum(["eq", "neq", "in", "gte", "lte"]),
   value: ConditionValueSchema
 });
-var ConfiguratorRuleSchema = z2.discriminatedUnion("kind", [
+var ConfiguratorRuleSchema = z4.discriminatedUnion("kind", [
   /** Show `param` only while `when` holds. */
-  z2.strictObject({
-    kind: z2.literal("visible"),
+  z4.strictObject({
+    kind: z4.literal("visible"),
     param: ConfiguratorNameSchema,
     when: ConfiguratorConditionSchema
   }),
   /** Narrow a number parameter: `max cabinet_height = total_height - 300`. */
-  z2.strictObject({
-    kind: z2.literal("limit"),
+  z4.strictObject({
+    kind: z4.literal("limit"),
     param: ConfiguratorNameSchema,
-    bound: z2.enum(["min", "max"]),
+    bound: z4.enum(["min", "max"]),
     formula: FormulaSchema
   }),
   /** While `when` holds, these codes of a choice or material are not offered. */
-  z2.strictObject({
-    kind: z2.literal("exclude"),
+  z4.strictObject({
+    kind: z4.literal("exclude"),
     param: ConfiguratorNameSchema,
-    codes: z2.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
+    codes: z4.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
     when: ConfiguratorConditionSchema
   })
 ]);
@@ -1008,23 +1195,23 @@ var PriceRuleBase = {
   /** How many times the amount counts, e.g. `compartments`. Absent is once. */
   multiplier: FormulaSchema.optional()
 };
-var ConfiguratorPriceRuleSchema = z2.discriminatedUnion("kind", [
+var ConfiguratorPriceRuleSchema = z4.discriminatedUnion("kind", [
   /** The surcharge the model gives the chosen option. */
-  z2.strictObject({
+  z4.strictObject({
     ...PriceRuleBase,
-    kind: z2.literal("choice"),
+    kind: z4.literal("choice"),
     param: ConfiguratorNameSchema
   }),
   /** The surcharge of the chosen material's price group. */
-  z2.strictObject({
+  z4.strictObject({
     ...PriceRuleBase,
-    kind: z2.literal("material"),
+    kind: z4.literal("material"),
     param: ConfiguratorNameSchema
   }),
   /** An amount, counted while a switch is on. */
-  z2.strictObject({
+  z4.strictObject({
     ...PriceRuleBase,
-    kind: z2.literal("toggle"),
+    kind: z4.literal("toggle"),
     param: ConfiguratorNameSchema,
     amount: ConfiguratorNameSchema
   }),
@@ -1032,10 +1219,10 @@ var ConfiguratorPriceRuleSchema = z2.discriminatedUnion("kind", [
    * A price on measure: `max(0, total_width - 1800) / 1000 * meter_price`.
    * Reads number parameters (in their unit) and amounts (in cents).
    */
-  z2.strictObject({
+  z4.strictObject({
     key: ConfiguratorNameSchema,
     label: LabelSchema,
-    kind: z2.literal("formula"),
+    kind: z4.literal("formula"),
     formula: FormulaSchema
   })
 ]);
@@ -1045,73 +1232,73 @@ var CONFIGURATOR_SCENE_LIGHTINGS = [
   "daylight"
 ];
 var CONFIGURATOR_SCENE_EDGES = ["soft", "sharp"];
-var RoomColorSchema = z2.strictObject({
+var RoomColorSchema = z4.strictObject({
   code: ConfiguratorCodeSchema,
   label: LabelSchema,
-  color: z2.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor")
+  color: z4.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor")
 });
-var roomSurfaceSchema = (max) => z2.strictObject({
+var roomSurfaceSchema = (max) => z4.strictObject({
   /** The code shown first; absent is the first option. */
   default: ConfiguratorCodeSchema.optional(),
   /** Absent offers the package's own palette (`room-palette.ts`). */
-  options: z2.array(RoomColorSchema).min(1).max(max).optional()
+  options: z4.array(RoomColorSchema).min(1).max(max).optional()
 });
-var ConfiguratorRoomSchema = z2.strictObject({
+var ConfiguratorRoomSchema = z4.strictObject({
   wall: roomSurfaceSchema(CONFIGURATOR_LIMITS.roomWallOptions).optional(),
   floor: roomSurfaceSchema(CONFIGURATOR_LIMITS.roomFloorOptions).optional(),
   /** Millimetres of room beside the furniture on each side; 1500 by default. */
-  margin: z2.number().min(0).max(5e3).optional(),
+  margin: z4.number().min(0).max(5e3).optional(),
   /** Millimetres of floor in front of the wall; 3500 by default. */
-  depth: z2.number().min(1e3).max(1e4).optional()
+  depth: z4.number().min(1e3).max(1e4).optional()
 });
-var ConfiguratorSceneSchema = z2.strictObject({
-  lighting: z2.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
-  edges: z2.enum(CONFIGURATOR_SCENE_EDGES).optional(),
+var ConfiguratorSceneSchema = z4.strictObject({
+  lighting: z4.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
+  edges: z4.enum(CONFIGURATOR_SCENE_EDGES).optional(),
   room: ConfiguratorRoomSchema.optional()
 });
-var FocusNameSchema = z2.string().regex(/^[a-z][a-z0-9_]{0,39}$/, "configurator.invalidName");
-var ConfiguratorFocusSchema = z2.strictObject({
+var FocusNameSchema = z4.string().regex(/^[a-z][a-z0-9_]{0,39}$/, "configurator.invalidName");
+var ConfiguratorFocusSchema = z4.strictObject({
   param: ConfiguratorNameSchema,
   when: ConfiguratorConditionSchema.optional(),
-  open: z2.array(FocusNameSchema).max(CONFIGURATOR_LIMITS.focusNames).optional(),
-  frame: z2.array(FocusNameSchema).min(1).max(CONFIGURATOR_LIMITS.focusNames).optional(),
-  night: z2.boolean().optional()
+  open: z4.array(FocusNameSchema).max(CONFIGURATOR_LIMITS.focusNames).optional(),
+  frame: z4.array(FocusNameSchema).min(1).max(CONFIGURATOR_LIMITS.focusNames).optional(),
+  night: z4.boolean().optional()
 });
-var structureObjectSchema = (files) => z2.strictObject({
-  schemaVersion: z2.literal(1),
+var structureObjectSchema = (files) => z4.strictObject({
+  schemaVersion: z4.literal(1),
   geometry: geometryDocumentSchema(files.model),
   /**
    * How the scene is presented. Part of the structure and not of the shape
    * document, so the owner sets it under `crm.manage` like a material.
    */
   scene: ConfiguratorSceneSchema.optional(),
-  tabs: z2.array(
-    z2.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  tabs: z4.array(
+    z4.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
   ).min(1).max(CONFIGURATOR_LIMITS.tabs),
-  parameters: z2.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
-  choiceLists: z2.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
-  materials: z2.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
-  priceGroups: z2.array(
-    z2.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })
+  parameters: z4.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
+  choiceLists: z4.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
+  materials: z4.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
+  priceGroups: z4.array(
+    z4.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })
   ).max(CONFIGURATOR_LIMITS.priceGroups),
   /** Named amounts a model fills in and price rules read (`meter_price`). */
-  amounts: z2.array(
-    z2.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  amounts: z4.array(
+    z4.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: z2.strictObject({
+  presets: z4.strictObject({
     label: LabelSchema,
     tab: ConfiguratorNameSchema,
-    sets: z2.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
-    required: z2.boolean()
+    sets: z4.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
+    required: z4.boolean()
   }).optional(),
-  rules: z2.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
+  rules: z4.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
   /** What the picture opens and looks at when a choice changes. */
-  focus: z2.array(ConfiguratorFocusSchema).max(CONFIGURATOR_LIMITS.focus).optional(),
-  priceRules: z2.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
+  focus: z4.array(ConfiguratorFocusSchema).max(CONFIGURATOR_LIMITS.focus).optional(),
+  priceRules: z4.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
 });
 var ConfiguratorStructureObjectSchema = structureObjectSchema({
   picture: TexturePathSchema,
@@ -1599,55 +1786,55 @@ function parameterResolutionOrder(structure) {
 }
 
 // ../features/product-configurator/src/shared/configurator-value.schema.ts
-import { z as z3 } from "zod";
-var CentsSchema = z3.number().int().min(0).max(1e8);
+import { z as z5 } from "zod";
+var CentsSchema = z5.number().int().min(0).max(1e8);
 var PriceSchema = CentsSchema.nullable();
-var ConfiguratorValueObjectSchema = z3.strictObject({
+var ConfiguratorValueObjectSchema = z5.strictObject({
   /** Null: the model has no price of its own, every quote is "open". */
   basePriceCents: PriceSchema,
-  numbers: z3.record(
+  numbers: z5.record(
     ConfiguratorNameSchema,
-    z3.strictObject({
-      min: z3.number().finite(),
-      max: z3.number().finite(),
-      default: z3.number().finite()
+    z5.strictObject({
+      min: z5.number().finite(),
+      max: z5.number().finite(),
+      default: z5.number().finite()
     })
   ).default({}),
   /** Per choice list: the options this model offers, with their surcharge. */
-  choices: z3.record(
+  choices: z5.record(
     ConfiguratorNameSchema,
-    z3.strictObject({
-      options: z3.record(
+    z5.strictObject({
+      options: z5.record(
         ConfiguratorCodeSchema,
-        z3.strictObject({ priceCents: PriceSchema })
+        z5.strictObject({ priceCents: PriceSchema })
       ),
       default: ConfiguratorCodeSchema.optional()
     })
   ).default({}),
   /** Per material parameter: the materials this model offers. */
-  materials: z3.record(
+  materials: z5.record(
     ConfiguratorNameSchema,
-    z3.strictObject({
-      offered: z3.array(ConfiguratorCodeSchema).max(CONFIGURATOR_LIMITS.materials),
+    z5.strictObject({
+      offered: z5.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: z3.record(
+  toggles: z5.record(
     ConfiguratorNameSchema,
-    z3.strictObject({ offered: z3.boolean(), default: z3.boolean() })
+    z5.strictObject({ offered: z5.boolean(), default: z5.boolean() })
   ).default({}),
   /** The surcharge of each material price group. */
-  priceGroups: z3.record(ConfiguratorCodeSchema, PriceSchema).default({}),
+  priceGroups: z5.record(ConfiguratorCodeSchema, PriceSchema).default({}),
   /** The amounts the structure names, such as a price per metre. */
-  amounts: z3.record(ConfiguratorNameSchema, PriceSchema).default({}),
-  presets: z3.array(
-    z3.strictObject({
+  amounts: z5.record(ConfiguratorNameSchema, PriceSchema).default({}),
+  presets: z5.array(
+    z5.strictObject({
       code: ConfiguratorCodeSchema,
-      label: z3.string().trim().min(1).max(80),
+      label: z5.string().trim().min(1).max(80),
       /** A product of the same account this preset stands for, e.g. the fireplace. */
-      productId: z3.string().uuid().nullable(),
-      values: z3.record(ConfiguratorNameSchema, z3.number().finite())
+      productId: z5.string().uuid().nullable(),
+      values: z5.record(ConfiguratorNameSchema, z5.number().finite())
     })
   ).max(CONFIGURATOR_LIMITS.presets).default([])
 });
@@ -2148,13 +2335,13 @@ var PRODUCT_OPTION_LIMITS = {
   choicesBytes: 8 * 1024,
   maxSurchargeCents: 1e8
 };
-var KeySchema = z4.string().regex(/^[a-z0-9_]{1,40}$/, {
+var KeySchema = z6.string().regex(/^[a-z0-9_]{1,40}$/, {
   // i18n-exempt: returned verbatim to an integration's own code, never rendered in this app's UI
   message: "A key is 1 to 40 lower-case letters, digits or underscores"
 });
-var LabelSchema2 = z4.string().trim().min(1).max(PRODUCT_OPTION_LIMITS.labelLength);
-var SurchargeSchema = z4.number().int().min(0).max(PRODUCT_OPTION_LIMITS.maxSurchargeCents);
-var ProductOptionChoiceSchema = z4.object({
+var LabelSchema2 = z6.string().trim().min(1).max(PRODUCT_OPTION_LIMITS.labelLength);
+var SurchargeSchema = z6.number().int().min(0).max(PRODUCT_OPTION_LIMITS.maxSurchargeCents);
+var ProductOptionChoiceSchema = z6.object({
   key: KeySchema,
   label: LabelSchema2,
   surchargeCents: SurchargeSchema
@@ -2162,26 +2349,26 @@ var ProductOptionChoiceSchema = z4.object({
 var OptionFields = {
   key: KeySchema,
   label: LabelSchema2,
-  helpText: z4.string().trim().max(PRODUCT_OPTION_LIMITS.helpTextLength).nullable().default(null),
-  required: z4.boolean().default(false),
-  surchargePerUnit: z4.boolean().default(true)
+  helpText: z6.string().trim().max(PRODUCT_OPTION_LIMITS.helpTextLength).nullable().default(null),
+  required: z6.boolean().default(false),
+  surchargePerUnit: z6.boolean().default(true)
 };
-var ProductOptionSchema = z4.discriminatedUnion("kind", [
-  z4.object({
+var ProductOptionSchema = z6.discriminatedUnion("kind", [
+  z6.object({
     ...OptionFields,
-    kind: z4.literal("text"),
-    maxLength: z4.number().int().min(1).max(PRODUCT_OPTION_LIMITS.textLength),
+    kind: z6.literal("text"),
+    maxLength: z6.number().int().min(1).max(PRODUCT_OPTION_LIMITS.textLength),
     surchargeCents: SurchargeSchema.default(0)
   }),
-  z4.object({
+  z6.object({
     ...OptionFields,
-    kind: z4.literal("checkbox"),
+    kind: z6.literal("checkbox"),
     surchargeCents: SurchargeSchema.default(0)
   }),
-  z4.object({
+  z6.object({
     ...OptionFields,
-    kind: z4.literal("choice"),
-    choices: z4.array(ProductOptionChoiceSchema).min(PRODUCT_OPTION_LIMITS.minChoices).max(PRODUCT_OPTION_LIMITS.maxChoices)
+    kind: z6.literal("choice"),
+    choices: z6.array(ProductOptionChoiceSchema).min(PRODUCT_OPTION_LIMITS.minChoices).max(PRODUCT_OPTION_LIMITS.maxChoices)
   })
 ]).superRefine((option, context) => {
   if (option.kind !== "choice") {
@@ -2205,7 +2392,7 @@ var ProductOptionSchema = z4.discriminatedUnion("kind", [
     });
   }
 });
-var ProductOptionsSchema = z4.array(ProductOptionSchema).max(PRODUCT_OPTION_LIMITS.options).superRefine((options, context) => {
+var ProductOptionsSchema = z6.array(ProductOptionSchema).max(PRODUCT_OPTION_LIMITS.options).superRefine((options, context) => {
   const keys = options.map((option) => option.key);
   if (new Set(keys).size !== keys.length) {
     context.addIssue({
@@ -2232,47 +2419,47 @@ var MAX_AMOUNT_CENTS = 99999999;
 // ../features/crm-invoicing/src/schema/catalog-api.schema.ts
 var WEB_SLUG = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var FIELD_SLUG = /^[a-z][a-z0-9_]*$/;
-var CatalogSourceSchema = z5.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, {
+var CatalogSourceSchema = z7.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, {
   message: (
     // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
     'A source is lower-case letters, digits and hyphens, at most 64 characters (for example "coolflames-payload").'
   )
 });
-var CatalogExternalRefSchema = z5.string().trim().min(1).max(255);
-var CatalogWebSlugSchema = z5.string().min(2).max(64).regex(WEB_SLUG, {
+var CatalogExternalRefSchema = z7.string().trim().min(1).max(255);
+var CatalogWebSlugSchema = z7.string().min(2).max(64).regex(WEB_SLUG, {
   // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
   message: "An address is lower-case letters and digits joined by hyphens."
 });
-var CatalogFieldSlugSchema = z5.string().max(63).regex(FIELD_SLUG, {
+var CatalogFieldSlugSchema = z7.string().max(63).regex(FIELD_SLUG, {
   message: (
     // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
     "A field slug starts with a letter and holds lower-case letters, digits and underscores."
   )
 });
-var cents = z5.number().int().min(0).max(MAX_AMOUNT_CENTS);
-var CatalogCategoryPlacementSchema = z5.object({
+var cents = z7.number().int().min(0).max(MAX_AMOUNT_CENTS);
+var CatalogCategoryPlacementSchema = z7.object({
   slug: CatalogWebSlugSchema,
   /** Lowest first; equal places stand in id order. */
-  position: z5.number().int().min(-1e6).max(1e6).optional()
+  position: z7.number().int().min(-1e6).max(1e6).optional()
 }).strict();
-var text = (max) => z5.string().trim().max(max).nullable().optional();
-var CatalogPriceSchema = z5.object({
+var text = (max) => z7.string().trim().max(max).nullable().optional();
+var CatalogPriceSchema = z7.object({
   /** The price's own id at the source, so a renamed price stays itself. */
   externalRef: CatalogExternalRefSchema.optional(),
-  label: z5.string().trim().min(1).max(120),
+  label: z7.string().trim().min(1).max(120),
   /**
    * ISO 4217. Left out, the price is in the product's own currency. A
    * price in another currency is the fixed price for that currency: it
    * wins over a converted one and is never the default.
    */
-  currency: z5.string().regex(/^[A-Z]{3}$/).optional(),
+  currency: z7.string().regex(/^[A-Z]{3}$/).optional(),
   amountCents: cents,
   compareAtCents: cents.nullable().optional(),
-  kind: z5.enum(["one_off", "recurring"]).optional(),
-  recurringInterval: z5.enum(["day", "week", "month", "year"]).optional(),
-  recurringIntervalCount: z5.number().int().min(1).max(365).optional(),
-  isDefault: z5.boolean().optional(),
-  active: z5.boolean().optional()
+  kind: z7.enum(["one_off", "recurring"]).optional(),
+  recurringInterval: z7.enum(["day", "week", "month", "year"]).optional(),
+  recurringIntervalCount: z7.number().int().min(1).max(365).optional(),
+  isDefault: z7.boolean().optional(),
+  active: z7.boolean().optional()
 }).strict().superRefine((price, ctx) => {
   if ((price.kind ?? "one_off") === "recurring" && !price.recurringInterval) {
     ctx.addIssue({
@@ -2283,7 +2470,7 @@ var CatalogPriceSchema = z5.object({
     });
   }
 });
-var pricesSchema = z5.array(CatalogPriceSchema).min(1).max(50).superRefine((prices, ctx) => {
+var pricesSchema = z7.array(CatalogPriceSchema).min(1).max(50).superRefine((prices, ctx) => {
   if (prices.filter((price) => price.isDefault).length > 1) {
     ctx.addIssue({
       code: "custom",
@@ -2312,24 +2499,24 @@ var pricesSchema = z5.array(CatalogPriceSchema).min(1).max(50).superRefine((pric
     });
   }
 });
-var HttpsUrlSchema = z5.string().max(2048).url().refine((url) => url.startsWith("https://"), {
+var HttpsUrlSchema = z7.string().max(2048).url().refine((url) => url.startsWith("https://"), {
   // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
   message: "A file is fetched over https only."
 });
-var UploadPathSchema = z5.string().min(1).max(200);
-var CatalogFileRefSchema = z5.union([
-  z5.object({ url: HttpsUrlSchema }).strict(),
-  z5.object({ upload: UploadPathSchema }).strict()
+var UploadPathSchema = z7.string().min(1).max(200);
+var CatalogFileRefSchema = z7.union([
+  z7.object({ url: HttpsUrlSchema }).strict(),
+  z7.object({ upload: UploadPathSchema }).strict()
 ]);
 var IMAGE_ROLE = /^[a-z][a-z0-9_-]{0,31}$/;
-var CatalogImageDetailsSchema = z5.record(
-  z5.string().min(1).max(64),
-  z5.union([z5.string().max(500), z5.number().finite(), z5.boolean()])
+var CatalogImageDetailsSchema = z7.record(
+  z7.string().min(1).max(64),
+  z7.union([z7.string().max(500), z7.number().finite(), z7.boolean()])
 ).refine((details) => JSON.stringify(details).length <= 1800, {
   // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
   message: "Details are at most about 2 KB."
 });
-var CatalogImageSchema = z5.object({
+var CatalogImageSchema = z7.object({
   url: HttpsUrlSchema.optional(),
   upload: UploadPathSchema.optional(),
   alt: text(300),
@@ -2337,7 +2524,7 @@ var CatalogImageSchema = z5.object({
    * What the picture is of, in the account's own words: `work`, `detail`,
    * `insitu`. Left out keeps the role a stored picture has; `null` clears it.
    */
-  role: z5.string().regex(IMAGE_ROLE, {
+  role: z7.string().regex(IMAGE_ROLE, {
     message: (
       // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
       "A role starts with a letter and holds lower-case letters, digits, hyphens and underscores, at most 32."
@@ -2351,33 +2538,33 @@ var CatalogImageSchema = z5.object({
     message: "A picture names either a url or an upload, not both."
   }
 );
-var CatalogStockSchema = z5.object({
-  managed: z5.boolean(),
+var CatalogStockSchema = z7.object({
+  managed: z7.boolean(),
   /** Left out, the count stays as it is. */
-  quantity: z5.number().int().min(0).max(1e9).optional(),
+  quantity: z7.number().int().min(0).max(1e9).optional(),
   /** Below this a product counts as running low; `null` warns never. */
-  lowThreshold: z5.number().int().min(0).max(1e9).nullable().optional(),
+  lowThreshold: z7.number().int().min(0).max(1e9).nullable().optional(),
   /** Whether it can still be ordered at zero: `deny`, `allow`, or `allow_notify`. */
-  backorders: z5.enum(["deny", "allow", "allow_notify"]).optional()
+  backorders: z7.enum(["deny", "allow", "allow_notify"]).optional()
 }).strict();
-var CatalogVariantAxisSchema = z5.object({
+var CatalogVariantAxisSchema = z7.object({
   slug: CatalogFieldSlugSchema,
-  label: z5.string().trim().min(1).max(120).optional()
+  label: z7.string().trim().min(1).max(120).optional()
 }).strict();
-var CatalogVariantSchema = z5.object({
+var CatalogVariantSchema = z7.object({
   externalRef: CatalogExternalRefSchema,
   /** The value per axis, keyed by the axis slug. */
-  options: z5.record(
+  options: z7.record(
     CatalogFieldSlugSchema,
-    z5.string().trim().min(1).max(120)
+    z7.string().trim().min(1).max(120)
   ),
   sku: text(100),
-  gtin: z5.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
+  gtin: z7.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
   prices: pricesSchema.optional(),
   /** The variant's own shelf; a physical product counts per variant. */
   stock: CatalogStockSchema.optional(),
-  position: z5.number().int().min(0).max(1e4).optional(),
-  active: z5.boolean().optional()
+  position: z7.number().int().min(0).max(1e4).optional(),
+  active: z7.boolean().optional()
 }).strict();
 var CATALOG_AVAILABILITIES = [
   "draft",
@@ -2385,26 +2572,26 @@ var CATALOG_AVAILABILITIES = [
   "scheduled",
   "public"
 ];
-var CatalogProductUpsertSchema = z5.object({
+var CatalogProductUpsertSchema = z7.object({
   source: CatalogSourceSchema,
   /** Required to create a product; optional to update one. */
-  name: z5.string().trim().min(1).max(500).optional(),
+  name: z7.string().trim().min(1).max(500).optional(),
   slug: CatalogWebSlugSchema.nullable().optional(),
   description: text(5e3),
   /** HTML; cleaned against the same allow-list the app uses. */
   longDescription: text(1e5),
   sku: text(100),
-  gtin: z5.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
-  productType: z5.enum(["digital", "physical"]).optional(),
+  gtin: z7.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
+  productType: z7.enum(["digital", "physical"]).optional(),
   /**
    * Where the product stands. A new product is a `draft` unless this says
    * otherwise -- an import should not put a hundred products on somebody's
    * website because a run finished.
    */
-  availability: z5.enum(CATALOG_AVAILABILITIES).optional(),
+  availability: z7.enum(CATALOG_AVAILABILITIES).optional(),
   /** The moment for `scheduled`; ignored for the other three. */
-  publishedAt: z5.string().datetime({ offset: true }).nullable().optional(),
-  visibility: z5.enum(["public", "unlisted"]).optional(),
+  publishedAt: z7.string().datetime({ offset: true }).nullable().optional(),
+  visibility: z7.enum(["public", "unlisted"]).optional(),
   metaTitle: text(300),
   metaDescription: text(1e3),
   /**
@@ -2422,21 +2609,21 @@ var CatalogProductUpsertSchema = z5.object({
    * product stands on that category's page (`?sort=position`, lowest
    * first); a plain slug leaves a stored place as it is.
    */
-  categories: z5.array(z5.union([CatalogWebSlugSchema, CatalogCategoryPlacementSchema])).max(50).optional(),
+  categories: z7.array(z7.union([CatalogWebSlugSchema, CatalogCategoryPlacementSchema])).max(50).optional(),
   /**
    * Make a category that does not exist yet instead of refusing. Off unless
    * asked for, so a typo cannot become a category on a customer's website.
    */
-  createMissingCategories: z5.boolean().optional(),
+  createMissingCategories: z7.boolean().optional(),
   /** Field values by field slug; `null` empties one field. */
-  fields: z5.record(CatalogFieldSlugSchema, z5.unknown()).optional(),
+  fields: z7.record(CatalogFieldSlugSchema, z7.unknown()).optional(),
   /** Which fields the product's own page shows, in that order. */
-  publicFields: z5.array(CatalogFieldSlugSchema).max(100).optional(),
+  publicFields: z7.array(CatalogFieldSlugSchema).max(100).optional(),
   /**
    * Add a choice a select field does not offer yet instead of refusing.
    * Off unless asked for, for the same reason as categories.
    */
-  addMissingOptions: z5.boolean().optional(),
+  addMissingOptions: z7.boolean().optional(),
   /** Replaces the product's prices as a whole. */
   prices: pricesSchema.optional(),
   /**
@@ -2445,29 +2632,29 @@ var CatalogProductUpsertSchema = z5.object({
    */
   stock: CatalogStockSchema.optional(),
   /** Replaces the product's pictures, in this order. */
-  images: z5.array(CatalogImageSchema).max(20).optional(),
-  variantAxes: z5.array(CatalogVariantAxisSchema).min(1).max(3).optional(),
+  images: z7.array(CatalogImageSchema).max(20).optional(),
+  variantAxes: z7.array(CatalogVariantAxisSchema).min(1).max(3).optional(),
   /** Replaces the product's variants; one missing here is archived. */
-  variants: z5.array(CatalogVariantSchema).max(100).optional(),
+  variants: z7.array(CatalogVariantSchema).max(100).optional(),
   /** `false` brings back a product the API archived earlier. */
-  archived: z5.literal(false).optional(),
+  archived: z7.literal(false).optional(),
   /**
    * Sold only as an extra with another product -- a warranty, assembly --
    * and how: at most `maxQuantity` per piece or per line, following the
    * quantity of its line (`perPiece`), and whether only the team adds it
    * (`teamOnly`). `null` makes it a product of its own again.
    */
-  soldAsExtra: z5.object({
-    maxQuantity: z5.number().int().min(1).max(99).default(1),
-    perPiece: z5.boolean().default(false),
-    teamOnly: z5.boolean().default(false)
+  soldAsExtra: z7.object({
+    maxQuantity: z7.number().int().min(1).max(99).default(1),
+    perPiece: z7.boolean().default(false),
+    teamOnly: z7.boolean().default(false)
   }).strict().nullable().optional(),
   /**
    * Replaces what may be taken with this product, in this order: each the
    * `externalRef` of another product of the same source and the same
    * catalogue. `[]` takes them all off.
    */
-  extras: z5.array(CatalogExternalRefSchema).max(50).optional(),
+  extras: z7.array(CatalogExternalRefSchema).max(50).optional(),
   /**
    * Replaces what a buyer chooses or types on this product, with a
    * surcharge in the account's own currency (`ProductOptionsSchema`).
@@ -2546,8 +2733,8 @@ var CatalogProductUpsertSchema = z5.object({
     });
   }
 });
-var CatalogProductArchiveSchema = z5.object({ source: CatalogSourceSchema }).strict();
-var CatalogCategoryUpsertSchema = z5.object({
+var CatalogProductArchiveSchema = z7.object({ source: CatalogSourceSchema }).strict();
+var CatalogCategoryUpsertSchema = z7.object({
   /**
    * The category's id in the system it came from -- a series in a site's
    * own CMS -- with `source` naming whose id it is. With both, a category
@@ -2557,12 +2744,12 @@ var CatalogCategoryUpsertSchema = z5.object({
    */
   source: CatalogSourceSchema.optional(),
   externalRef: CatalogExternalRefSchema.optional(),
-  name: z5.string().trim().min(1).max(200).optional(),
+  name: z7.string().trim().min(1).max(200).optional(),
   description: text(5e3),
   /** `null` puts the category at the top of the tree. */
   parentSlug: CatalogWebSlugSchema.nullable().optional(),
-  availability: z5.enum(CATALOG_AVAILABILITIES).optional(),
-  publishedAt: z5.string().datetime({ offset: true }).nullable().optional(),
+  availability: z7.enum(CATALOG_AVAILABILITIES).optional(),
+  publishedAt: z7.string().datetime({ offset: true }).nullable().optional(),
   metaTitle: text(300),
   metaDescription: text(1e3)
 }).strict().refine(
@@ -2573,19 +2760,19 @@ var CatalogCategoryUpsertSchema = z5.object({
     message: "A category reference names both source and externalRef."
   }
 );
-var CatalogObjectSlugSchema = z5.string().max(64).regex(FIELD_SLUG, {
+var CatalogObjectSlugSchema = z7.string().max(64).regex(FIELD_SLUG, {
   message: (
     // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
     "A catalogue slug starts with a letter and holds lower-case letters, digits and underscores."
   )
 });
-var CatalogCatalogueUpsertSchema = z5.object({
-  nameSingular: z5.string().trim().min(1).max(120).optional(),
-  namePlural: z5.string().trim().min(1).max(120).optional(),
+var CatalogCatalogueUpsertSchema = z7.object({
+  nameSingular: z7.string().trim().min(1).max(120).optional(),
+  namePlural: z7.string().trim().min(1).max(120).optional(),
   /** A lucide icon name, as the object settings offer them. */
-  icon: z5.string().trim().max(64).nullable().optional()
+  icon: z7.string().trim().max(64).nullable().optional()
 }).strict();
-var CatalogFieldTypeSchema = z5.enum([
+var CatalogFieldTypeSchema = z7.enum([
   "text",
   "number",
   "select",
@@ -2599,21 +2786,21 @@ var CatalogFieldTypeSchema = z5.enum([
   "configurator"
 ]);
 var CATALOG_FIELD_TYPES = CatalogFieldTypeSchema.options;
-var CatalogFieldOptionSchema = z5.object({
-  value: z5.string().trim().min(1).max(120),
-  label: z5.string().trim().min(1).max(120).optional()
+var CatalogFieldOptionSchema = z7.object({
+  value: z7.string().trim().min(1).max(120),
+  label: z7.string().trim().min(1).max(120).optional()
 }).strict();
-var CatalogAttributeUpsertSchema = z5.object({
-  label: z5.string().trim().min(1).max(120).optional(),
+var CatalogAttributeUpsertSchema = z7.object({
+  label: z7.string().trim().min(1).max(120).optional(),
   type: CatalogFieldTypeSchema.optional(),
   /** For a select: whether a product may carry more than one choice. */
-  multiple: z5.boolean().optional(),
+  multiple: z7.boolean().optional(),
   /** Choices to make sure exist; never removes one that is not listed. */
-  options: z5.array(CatalogFieldOptionSchema).max(500).optional(),
+  options: z7.array(CatalogFieldOptionSchema).max(500).optional(),
   /** Choices to take off the list, by value. */
-  removeOptions: z5.array(z5.string().trim().min(1).max(120)).max(500).optional(),
+  removeOptions: z7.array(z7.string().trim().min(1).max(120)).max(500).optional(),
   /** Whether the public API may show this field at all. */
-  public: z5.boolean().optional(),
+  public: z7.boolean().optional(),
   /**
    * The field's settings, replaced as a whole. Checked against the same
    * schema the object builder saves with, per type: a repeater's `display`,
@@ -2621,47 +2808,47 @@ var CatalogAttributeUpsertSchema = z5.object({
    * a configurator's whole structure. An item field keeps its type once it
    * exists.
    */
-  config: z5.record(z5.string(), z5.unknown()).optional(),
+  config: z7.record(z7.string(), z7.unknown()).optional(),
   /**
    * Say what this body would change -- a new field, a new label, choices
    * added, choices taken away and how many products hold each -- and
    * write nothing.
    */
-  dryRun: z5.boolean().optional(),
+  dryRun: z7.boolean().optional(),
   /**
    * Bring the field back from the trash under its own id, with every value
    * the products kept. Nothing else may be sent with it.
    */
-  restore: z5.literal(true).optional(),
+  restore: z7.literal(true).optional(),
   /**
    * For a new content field (`content_text`, `repeater`, `cta`): put its
    * block at the end of the product page. On by default; `false` makes the
    * field only. Never moves or restores a block of an existing field.
    */
-  placeOnPage: z5.boolean().optional()
+  placeOnPage: z7.boolean().optional()
 }).strict();
 var CONFIGURATOR_FILE_KINDS = ["model", "texture"];
 var CONFIGURATOR_TEXTURE_CONTENT_TYPES = [
   "image/webp",
   "image/jpeg"
 ];
-var ConfiguratorFileUploadSchema = z5.discriminatedUnion("step", [
-  z5.object({
-    step: z5.literal("start"),
+var ConfiguratorFileUploadSchema = z7.discriminatedUnion("step", [
+  z7.object({
+    step: z7.literal("start"),
     /** The slug of the configurator field the file is for. */
     field: CatalogFieldSlugSchema,
-    kind: z5.enum(CONFIGURATOR_FILE_KINDS),
+    kind: z7.enum(CONFIGURATOR_FILE_KINDS),
     /** The bytes the caller is about to send, so a too-large file is refused before it travels. */
-    size: z5.number().int().min(1),
+    size: z7.number().int().min(1),
     /** For a texture: what kind of picture it is. A model is always glTF binary. */
-    contentType: z5.enum(CONFIGURATOR_TEXTURE_CONTENT_TYPES).optional()
+    contentType: z7.enum(CONFIGURATOR_TEXTURE_CONTENT_TYPES).optional()
   }).strict(),
-  z5.object({
-    step: z5.literal("finish"),
+  z7.object({
+    step: z7.literal("finish"),
     field: CatalogFieldSlugSchema,
-    kind: z5.enum(CONFIGURATOR_FILE_KINDS),
+    kind: z7.enum(CONFIGURATOR_FILE_KINDS),
     /** The `uploadPath` `start` answered with. */
-    uploadPath: z5.string().max(200)
+    uploadPath: z7.string().max(200)
   }).strict()
 ]);
 var CATALOG_FILE_KINDS = ["image", "file"];
@@ -2677,97 +2864,40 @@ var CATALOG_FILE_CONTENT_TYPES = [
   "text/csv",
   "application/zip"
 ];
-var CatalogFileUploadSchema = z5.discriminatedUnion("step", [
-  z5.object({
-    step: z5.literal("start"),
+var CatalogFileUploadSchema = z7.discriminatedUnion("step", [
+  z7.object({
+    step: z7.literal("start"),
     /** A picture (2 MB, png/jpeg/webp) or a download for a list item (20 MB). */
-    kind: z5.enum(CATALOG_FILE_KINDS),
+    kind: z7.enum(CATALOG_FILE_KINDS),
     /** The bytes about to be sent, so a too-large file is refused before it travels. */
-    size: z5.number().int().min(1),
-    contentType: z5.enum(CATALOG_FILE_CONTENT_TYPES)
+    size: z7.number().int().min(1),
+    contentType: z7.enum(CATALOG_FILE_CONTENT_TYPES)
   }).strict(),
-  z5.object({
-    step: z5.literal("finish"),
-    kind: z5.enum(CATALOG_FILE_KINDS),
+  z7.object({
+    step: z7.literal("finish"),
+    kind: z7.enum(CATALOG_FILE_KINDS),
     /** The `uploadPath` `start` answered with. */
-    uploadPath: z5.string().max(200)
+    uploadPath: z7.string().max(200)
   }).strict()
 ]);
 
 // src/catalog-tools.ts
-import { z as z7 } from "zod";
-
-// src/tool-answers.ts
-import { CrmApiError } from "@solumflow-app/crm-client";
-import { z as z6 } from "zod";
-function answer(text2, data) {
-  return {
-    content: [{ type: "text", text: text2 }],
-    structuredContent: { result: data }
-  };
-}
-function refusal(error, scope) {
-  if (!(error instanceof CrmApiError)) {
-    throw error;
-  }
-  const lines = [`${error.code}: ${error.message}`];
-  const next = error.code === "forbidden" ? `The key may not do this. It needs to be a secret key with the scope "${scope}".` : NEXT_STEP[error.code];
-  if (next) {
-    lines.push(next);
-  }
-  for (const field of error.fields) {
-    lines.push(`- ${field.path}: ${field.message}`);
-  }
-  return {
-    isError: true,
-    content: [{ type: "text", text: lines.join("\n") }]
-  };
-}
-var NEXT_STEP = {
-  unauthorized: "The key is not recognised or was revoked. Ask the account owner for a new secret key.",
-  feature_unavailable: "The module this needs is switched off for the account. Ask somebody to switch it on in the app.",
-  rate_limited: "Too many requests: 120 a minute per key, 600 per account, and 5 MB of bodies a day per key. Wait the seconds the answer names and try again.",
-  internal_error: "Something went wrong in the app. Trying again is safe."
-};
-function codeBlock(snippet) {
-  return `\`\`\`html
-${snippet}
-\`\`\``;
-}
-var page = {
-  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()
-};
-function more(nextCursor) {
-  return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
-}
-function money(cents3, currency2) {
-  return `${(cents3 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
-}
-function fieldsNotOnPageNote(slugs) {
-  if (!slugs?.length) {
-    return "";
-  }
-  const count = slugs.length === 1 ? "1 public field has" : `${slugs.length} public fields have`;
-  return ` ${count} a value but ${slugs.length === 1 ? "is" : "are"} not on this product's page: ${slugs.join(", ")}; send them in publicFields to show them.`;
-}
-
-// src/catalog-tools.ts
+import { z as z8 } from "zod";
 var objectInput = {
   object: CatalogObjectSlugSchema.optional().describe(
     "The slug of the catalogue (see list_catalogs). Leave out for the account\u2019s own catalogue."
   )
 };
 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. A new block field stands at the end of the product page from the moment upsert_field makes it (`placeOnPage: false` skips that).';
-var currency = z7.string().regex(/^[A-Z]{3}$/).optional().describe(
+var currency = z8.string().regex(/^[A-Z]{3}$/).optional().describe(
   "Every price in this currency (see list_currencies), each with its origin: base, fixed or converted. Left out, every price in its own currency."
 );
 var READ_STATUS_HINT = 'Left out, only published ones. "draft" is what is not on the website yet (concept, internal or scheduled), "archived" what was taken out, "all" everything; each answers with a `status` and `publishedAt` per item. Anything but published needs a key with catalog:write.';
-var productStatus = z7.enum(["published", "draft", "archived", "all"]).optional().describe(`Which products. ${READ_STATUS_HINT}`);
-var categoryStatus = z7.enum(["published", "draft", "all"]).optional().describe(
+var productStatus = z8.enum(["published", "draft", "archived", "all"]).optional().describe(`Which products. ${READ_STATUS_HINT}`);
+var categoryStatus = z8.enum(["published", "draft", "all"]).optional().describe(
   `Which categories. ${READ_STATUS_HINT.replace('"archived" what was taken out, ', "")} A category cannot be archived.`
 );
-var slugOrId = z7.string().min(1).max(200).describe("The address (slug) or the id of the product.");
+var slugOrId = z8.string().min(1).max(200).describe("The address (slug) or the id of the product.");
 function registerCatalogTools(server, client) {
   server.registerTool(
     "list_catalog_fields",
@@ -2817,7 +2947,7 @@ function registerCatalogTools(server, client) {
       title: "List the currencies the shop sells in",
       description: "The account\u2019s own currency first, then the ones it switched on, with a name and symbol: what a currency menu on a website is built from. Pass one as `currency` to get_product or list_products for prices in it. Which currencies are offered, and at what rate, is set in the app (Settings \u2192 Verkoop \u2192 Valuta), not through this tool.",
       inputSchema: {
-        locale: z7.string().min(2).max(35).optional().describe('The language names are written in, such as "nl".')
+        locale: z8.string().min(2).max(35).optional().describe('The language names are written in, such as "nl".')
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -2874,22 +3004,22 @@ function registerCatalogTools(server, client) {
       description: "One page of the catalogue: name, address (slug), lowest price, whether it is in stock, its first picture and the public fields a listing shows. Narrow it to one category\u2019s whole branch by its id or address, or by the reference upsert_category recorded (`categorySource` + `categoryRef`), to one catalogue by the slug of its object, or to the product carrying an article number (`sku`). Read get_product for everything a product page needs. Published products only, and may be a minute old; `status` lists concepts, scheduled and archived ones too (needs a server key). `sort` orders the published ones: -publishedAt (newest first, the default), publishedAt, name, or position -- the seller\u2019s own order on the page of `category`, which it needs. Each item carries `sku`, `publishedAt` and `stockQuantity` (null when not counted).",
       inputSchema: {
         ...page,
-        category: z7.string().regex(
+        category: z8.string().regex(
           /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[a-z0-9]+(-[a-z0-9]+)*)$/i
         ).max(64).optional().describe(
           "A category id or address (slug); includes its subcategories."
         ),
-        categorySource: z7.string().max(64).optional().describe("With categoryRef: whose id the category reference is."),
-        categoryRef: z7.string().max(255).optional().describe("A category by the id it has in your own system."),
-        sku: z7.string().min(1).max(100).optional().describe(
+        categorySource: z8.string().max(64).optional().describe("With categoryRef: whose id the category reference is."),
+        categoryRef: z8.string().max(255).optional().describe("A category by the id it has in your own system."),
+        sku: z8.string().min(1).max(100).optional().describe(
           "The product carrying this article number, or whose variant does."
         ),
-        object: z7.string().min(1).max(63).optional().describe(
+        object: z8.string().min(1).max(63).optional().describe(
           'One catalogue, by the slug of its object, such as "product".'
         ),
         currency,
         status: productStatus,
-        sort: z7.enum(["-publishedAt", "publishedAt", "name", "position"]).optional().describe(
+        sort: z8.enum(["-publishedAt", "publishedAt", "name", "position"]).optional().describe(
           "The order: newest first by default; position needs `category`."
         )
       },
@@ -2922,7 +3052,7 @@ function registerCatalogTools(server, client) {
       description: 'The categories of the catalogue, each with its path from the top and how many products are in it. Left without `parent`, every category comes back, which is what building a menu in one go needs; "root" asks for the top level, a category id for its children. Published categories only unless you pass `status` (draft or all, needs a server key).',
       inputSchema: {
         ...page,
-        parent: z7.union([z7.literal("root"), z7.string().uuid()]).optional().describe('"root" or the id of a category.'),
+        parent: z8.union([z8.literal("root"), z8.string().uuid()]).optional().describe('"root" or the id of a category.'),
         status: categoryStatus
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
@@ -2945,7 +3075,7 @@ function registerCatalogTools(server, client) {
       title: "Read one category page",
       description: "One category as its page needs it: name, description, the texts for search engines and social media, and the first page of its products. Pass the nextCursor back to page through the products. A category that is not on the website yet needs `status` (draft or all, a server key); its products are the published ones.",
       inputSchema: {
-        slugOrId: z7.string().min(1).max(200).describe("The address (slug) or the id of the category."),
+        slugOrId: z8.string().min(1).max(200).describe("The address (slug) or the id of the category."),
         ...page,
         status: categoryStatus
       },
@@ -3121,8 +3251,8 @@ function registerCatalogMigrationTools(server, client) {
       title: "Make or change many products",
       description: `Up to ${BULK_LIMIT} products, one after another, each exactly as upsert_product takes it (\`externalRef\` beside its body). A refusal is that product\u2019s outcome and the others go on; a refusal for speed is waited out and the product sent again; a key that is refused stops the run and the rest is \`skipped\`. Answers per product \`created\`, \`changed\`, \`refused\` (with the fields) or \`skipped\`. ` + LIMITS,
       inputSchema: {
-        products: z8.array(
-          z8.object({
+        products: z9.array(
+          z9.object({
             externalRef: CatalogExternalRefSchema,
             product: CatalogProductUpsertSchema
           })
@@ -3166,20 +3296,20 @@ function registerCatalogMigrationTools(server, client) {
       description: "Moves a field to the trash, as the app does: for thirty days it can come back with restore_field, and every product keeps its value meanwhile. Use `permanent` only when the user explicitly asks to delete for good, and first without `confirm`: that only counts the products that would lose their value. Show the user that count; send `confirm` (the slug again) only after they agree. A field of the app\u2019s own, or one a product varies along, is refused.",
       inputSchema: {
         slug: CatalogFieldSlugSchema,
-        permanent: z8.boolean().optional(),
-        confirm: z8.string().max(63).optional(),
+        permanent: z9.boolean().optional(),
+        confirm: z9.string().max(63).optional(),
         ...objectInput
       },
       annotations: { destructiveHint: true, idempotentHint: true }
     },
-    async ({ slug: slug2, permanent, confirm, object: object2 }) => {
+    async ({ slug: slug3, permanent, confirm, object: object2 }) => {
       try {
-        const result = await client.removeField(slug2, {
+        const result = await client.removeField(slug3, {
           ...target(object2),
           ...permanent ? { permanent } : {},
           ...confirm ? { confirm } : {}
         });
-        const text2 = result.state === "trashed" ? `${slug2} is in the trash until ${result.restorableUntil ?? "thirty days from now"}; ${result.productsWithValue} products keep their value.` : result.state === "would_delete" ? `Nothing changed. Deleting ${slug2} for good would clear its value on ${result.productsWithValue} products. ${result.confirm}` : `${slug2} is deleted; its value on ${result.productsWithValue} products is being cleared.`;
+        const text2 = result.state === "trashed" ? `${slug3} is in the trash until ${result.restorableUntil ?? "thirty days from now"}; ${result.productsWithValue} products keep their value.` : result.state === "would_delete" ? `Nothing changed. Deleting ${slug3} for good would clear its value on ${result.productsWithValue} products. ${result.confirm}` : `${slug3} is deleted; its value on ${result.productsWithValue} products is being cleared.`;
         return answer(text2, result);
       } catch (error) {
         return refusal(error, "catalog:write");
@@ -3194,9 +3324,9 @@ function registerCatalogMigrationTools(server, client) {
       inputSchema: { slug: CatalogFieldSlugSchema, ...objectInput },
       annotations: { destructiveHint: false, idempotentHint: true }
     },
-    async ({ slug: slug2, object: object2 }) => {
+    async ({ slug: slug3, object: object2 }) => {
       try {
-        const field = await client.restoreField(slug2, target(object2));
+        const field = await client.restoreField(slug3, target(object2));
         return answer(`${field.label} (${field.slug}) is back.`, field);
       } catch (error) {
         return refusal(error, "catalog:write");
@@ -3211,7 +3341,7 @@ function registerCatalogMigrationTools(server, client) {
       inputSchema: {
         source: CatalogSourceSchema,
         externalRef: CatalogExternalRefSchema,
-        status: z8.enum(["published", "draft", "all"]).optional().describe(
+        status: z9.enum(["published", "draft", "all"]).optional().describe(
           "Which categories to look in; anything but published needs catalog:write."
         )
       },
@@ -3239,8 +3369,8 @@ function registerCatalogMigrationTools(server, client) {
       title: "Upload a picture or a file from disk",
       description: 'Reads one file from the user\u2019s disk and uploads it, for a product write to name as { "upload": "<uploadPath>" } instead of a url: a picture (png, jpeg, webp, at most 2 MB) for `images`, `socialImage` or a list item\u2019s image, or a "file" (pdf, Office, txt, csv, zip, at most 20 MB) for a list item\u2019s download. An upload is kept a day.',
       inputSchema: {
-        kind: z8.enum(["image", "file"]),
-        filePath: z8.string().min(1).max(1e3).describe("The absolute path of the file on this machine.")
+        kind: z9.enum(["image", "file"]),
+        filePath: z9.string().min(1).max(1e3).describe("The absolute path of the file on this machine.")
       },
       annotations: { destructiveHint: false, idempotentHint: false }
     },
@@ -3483,10 +3613,10 @@ Archive it with archive_product instead.`
       },
       annotations: { destructiveHint: false, idempotentHint: true }
     },
-    async ({ slug: slug2, object: object2, ...input }) => {
+    async ({ slug: slug3, object: object2, ...input }) => {
       try {
         const category = await client.upsertCategory(
-          slug2,
+          slug3,
           input,
           target2(object2)
         );
@@ -3513,14 +3643,14 @@ Archive it with archive_product instead.`
       },
       annotations: { destructiveHint: true, idempotentHint: true }
     },
-    async ({ slug: slug2, object: object2, ...input }) => {
+    async ({ slug: slug3, object: object2, ...input }) => {
       try {
         if (input.dryRun) {
           const { dryRun: _dryRun, ...rest } = input;
-          const preview = await client.previewField(slug2, rest, target2(object2));
+          const preview = await client.previewField(slug3, rest, target2(object2));
           return answer(`Nothing written. ${JSON.stringify(preview)}`, preview);
         }
-        const field = await client.upsertField(slug2, input, target2(object2));
+        const field = await client.upsertField(slug3, input, target2(object2));
         return answer(
           `${field.created ? "Made" : "Changed"} ${field.label} (${field.slug}), ${field.type}, ${field.public ? "public" : "not public"}.` + (field.placedOnPage === void 0 ? "" : field.placedOnPage ? " Its block is at the end of the product page." : ` Its block is not on the product page (${field.notPlacedBecause ?? "not placed"}).`),
           field
@@ -3543,9 +3673,9 @@ Archive it with archive_product instead.`
       },
       annotations: { destructiveHint: false, idempotentHint: true }
     },
-    async ({ slug: slug2, ...input }) => {
+    async ({ slug: slug3, ...input }) => {
       try {
-        const catalog = await client.upsertCatalog(slug2, input);
+        const catalog = await client.upsertCatalog(slug3, input);
         return answer(
           `${catalog.created ? "Made" : "Changed"} ${catalog.namePlural} (${catalog.slug}).`,
           catalog
@@ -3557,8 +3687,106 @@ Archive it with archive_product instead.`
   );
 }
 
+// src/client-account-tools.ts
+import { z as z10 } from "zod";
+var RESELLER_ONLY = "Only on the key of a reseller, with clients:manage; only the customer accounts that reseller sold are reached.";
+function registerClientAccountTools(server, client) {
+  server.registerTool(
+    "list_client_accounts",
+    {
+      title: "List customer accounts",
+      description: `The customer accounts this reseller sold, paged by id: name, address, owner, kind and the modules switched on. ${RESELLER_ONLY}`,
+      inputSchema: { ...page },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const result = await client.getClientAccounts(input);
+        return answer(
+          result.data.length === 0 ? "No customer accounts." : [...result.data.map(describeAccount), more(result.nextCursor)].filter(Boolean).join("\n"),
+          result
+        );
+      } catch (error) {
+        return refusal(error, "clients:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "get_client_account",
+    {
+      title: "Read one customer account",
+      description: `One customer account of this reseller by id. ${RESELLER_ONLY}`,
+      inputSchema: { id: z10.string().uuid() },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ id: id7 }) => {
+      try {
+        const account = await client.getClientAccount(id7);
+        return account ? answer(describeAccount(account), account) : answer(`No customer account ${id7} under this reseller.`, null);
+      } catch (error) {
+        return refusal(error, "clients:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "create_client_account",
+    {
+      title: "Make a customer account",
+      description: `A customer account with a SolumFlow workspace of its own: the owner gets a login and a mail with the way in. Asked again for the same owner it makes nothing and answers with the account that owner already has. It starts with the default modules; set_client_modules sets the ones it is sold with. ${RESELLER_ONLY}`,
+      inputSchema: {
+        name: z10.string().min(1).max(255).describe("What the account is called: the customer\u2019s business."),
+        ownerEmail: z10.string().email().max(320).describe("Who owns it, and who gets the mail with the way in."),
+        slug: z10.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(63).optional().describe(
+          "The address in the app; derived from the name when left out."
+        )
+      },
+      annotations: { idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const result = await client.createClientAccount(input);
+        const said = result.created ? result.invited ? "Made, and its owner was mailed the way in." : "Made, but the mail to its owner did not go: give them access from the account\u2019s members in the app." : "That owner already had an account here; nothing was made.";
+        return answer(`${said}
+${describeAccount(result.account)}`, result);
+      } catch (error) {
+        return refusal(error, "clients:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "set_client_modules",
+    {
+      title: "Set a customer account\u2019s modules",
+      description: `The modules a customer account is sold with: every key named is switched on, every other ordinary module off; never an empty list. A module a paid package switched on and this changes is the reseller\u2019s choice from then on. Only modules this reseller may hand out; hosting, domains, mail hosting and site monitoring stay the platform owner\u2019s. Typical: crm, calendar, forms, chat, consent, payments. ${RESELLER_ONLY}`,
+      inputSchema: {
+        clientAccountId: z10.string().uuid(),
+        moduleKeys: z10.array(z10.string().regex(/^[a-z][a-z0-9_]{1,63}$/)).min(1).max(64)
+      },
+      annotations: { idempotentHint: true }
+    },
+    async ({ clientAccountId, moduleKeys }) => {
+      try {
+        const result = await client.setClientModules(
+          clientAccountId,
+          moduleKeys
+        );
+        const said = result.changed.length ? `Switched: ${result.changed.join(", ")}.` : "Nothing changed: the account already had exactly these.";
+        return answer(`${said}
+${describeAccount(result.account)}`, result);
+      } catch (error) {
+        return refusal(error, "clients:manage");
+      }
+    }
+  );
+}
+function describeAccount(account) {
+  const test = account.isTestAccount ? " (test)" : "";
+  const modules = account.modules.length ? account.modules.join(", ") : "no modules";
+  return `- ${account.name}${test} (id ${account.id}, ${account.slug}, ${account.kind}): owner ${account.ownerEmail ?? "unknown"}; ${modules}`;
+}
+
 // src/configurator-tools.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { extname as extname2 } from "path";
 var FILE_RULES2 = {
@@ -3569,7 +3797,7 @@ var FILE_RULES2 = {
   }
 };
 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", optional "scene" ({ "lighting": "studio" | "warm" | "daylight" }), "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), model (a "model" path to a .glb uploaded with upload_configurator_file, params.fit 0 contain or 1 stretch, params.paint 1 to use the slot material) 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. Texture paths in materials come from upload_configurator_file too. Making a configurator, or changing its "geometry", needs a key with the configurator:shape scope; everything around the shape needs only catalog:write.';
-var documentInput = z9.string().min(2).max(2e5).describe(
+var documentInput = z11.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) {
@@ -3601,16 +3829,16 @@ function registerConfiguratorTools(server, client) {
         slug: CatalogFieldSlugSchema.describe(
           "The slug of the configurator field."
         ),
-        label: z9.string().trim().min(1).max(120).optional(),
-        structure: z9.string().min(2).max(2e5).describe(
+        label: z11.string().trim().min(1).max(120).optional(),
+        structure: z11.string().min(2).max(2e5).describe(
           'The JSON text of the whole configurator structure (it has "schemaVersion").'
         ),
-        public: z9.boolean().optional().describe("Whether product pages may show the configurator."),
+        public: z11.boolean().optional().describe("Whether product pages may show the configurator."),
         ...objectInput
       },
       annotations: { destructiveHint: true, idempotentHint: true }
     },
-    async ({ slug: slug2, label, structure, public: isPublic, object: object2 }) => {
+    async ({ slug: slug3, label, structure, public: isPublic, object: object2 }) => {
       const problems = checkDocument(structure);
       if (problems.length > 0 || !structure.includes('"schemaVersion"')) {
         return {
@@ -3628,7 +3856,7 @@ function registerConfiguratorTools(server, client) {
       }
       try {
         const field = await client.upsertField(
-          slug2,
+          slug3,
           {
             ...label ? { label } : {},
             type: "configurator",
@@ -3655,8 +3883,8 @@ function registerConfiguratorTools(server, client) {
         fieldSlug: CatalogFieldSlugSchema.describe(
           "The slug of the configurator field."
         ),
-        kind: z9.enum(CONFIGURATOR_FILE_KINDS),
-        filePath: z9.string().min(1).max(1e3).describe("The absolute path of the file on this machine."),
+        kind: z11.enum(CONFIGURATOR_FILE_KINDS),
+        filePath: z11.string().min(1).max(1e3).describe("The absolute path of the file on this machine."),
         ...objectInput
       },
       annotations: { destructiveHint: false, idempotentHint: false }
@@ -3709,8 +3937,8 @@ function registerConfiguratorTools(server, client) {
       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: z9.string().min(1).max(200).describe("The address (slug) or the id of the product."),
-        field: z9.string().min(1).max(64).describe("The slug of the configurator field.")
+        slugOrId: z11.string().min(1).max(200).describe("The address (slug) or the id of the product."),
+        field: z11.string().min(1).max(64).describe("The slug of the configurator field.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -3792,7 +4020,7 @@ function isRecord(value) {
 }
 
 // src/consent-banner-tools.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 function registerConsentBannerTools(server, client) {
   server.registerTool(
     "get_consent_banner",
@@ -3819,16 +4047,16 @@ function registerConsentBannerTools(server, client) {
       title: "Set the cookie banner",
       description: "All of the banner\u2019s settings at once, as the screen in the app saves them. It changes the live site at once. `necessary` is always on and not sent.",
       inputSchema: {
-        enabled: z10.boolean(),
-        gtmContainerId: z10.string().max(20).describe("GTM-\u2026, or an empty string for none."),
-        privacyPolicyUrl: z10.string().max(2048).describe("https only, or an empty string for none."),
-        categories: z10.array(
-          z10.enum(["functionality", "measurement", "marketing", "experience"])
+        enabled: z12.boolean(),
+        gtmContainerId: z12.string().max(20).describe("GTM-\u2026, or an empty string for none."),
+        privacyPolicyUrl: z12.string().max(2048).describe("https only, or an empty string for none."),
+        categories: z12.array(
+          z12.enum(["functionality", "measurement", "marketing", "experience"])
         ).max(4),
-        defaultLanguage: z10.enum(["nl", "en"]),
-        layout: z10.enum(["banner", "dialog"]),
-        showLogo: z10.boolean(),
-        sendHashedUserData: z10.boolean()
+        defaultLanguage: z12.enum(["nl", "en"]),
+        layout: z12.enum(["banner", "dialog"]),
+        showLogo: z12.boolean(),
+        sendHashedUserData: z12.boolean()
       },
       annotations: { idempotentHint: true }
     },
@@ -3844,17 +4072,17 @@ function registerConsentBannerTools(server, client) {
 }
 
 // src/deal-tools.ts
-import { z as z11 } from "zod";
-var dealId = z11.string().uuid().describe("The id of the deal.");
+import { z as z13 } from "zod";
+var dealId = z13.string().uuid().describe("The id of the deal.");
 var dealFields = {
-  name: z11.string().min(1).max(200),
-  value: z11.number().nonnegative().nullable().optional().describe("In whole units of the currency, such as 1500 for \u20AC1,500."),
-  currency: z11.string().length(3).optional().describe("Three letters; EUR when left out."),
-  contactRecordId: z11.string().uuid().nullable().optional(),
-  companyRecordId: z11.string().uuid().nullable().optional(),
-  ownerId: z11.string().uuid().nullable().optional().describe("A member of the account."),
-  expectedCloseDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional().describe("YYYY-MM-DD."),
-  values: z11.record(z11.string(), z11.unknown()).optional().describe("Field values by slug. A field marked sensitive is refused.")
+  name: z13.string().min(1).max(200),
+  value: z13.number().nonnegative().nullable().optional().describe("In whole units of the currency, such as 1500 for \u20AC1,500."),
+  currency: z13.string().length(3).optional().describe("Three letters; EUR when left out."),
+  contactRecordId: z13.string().uuid().nullable().optional(),
+  companyRecordId: z13.string().uuid().nullable().optional(),
+  ownerId: z13.string().uuid().nullable().optional().describe("A member of the account."),
+  expectedCloseDate: z13.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional().describe("YYYY-MM-DD."),
+  values: z13.record(z13.string(), z13.unknown()).optional().describe("Field values by slug. A field marked sensitive is refused.")
 };
 function registerDealTools(server, client) {
   server.registerTool(
@@ -3886,9 +4114,9 @@ function registerDealTools(server, client) {
       title: "List deals",
       description: "Deals paged by id, open ones unless status says otherwise; pipeline narrows to one pipeline, q searches the name.",
       inputSchema: {
-        pipeline: z11.string().uuid().optional(),
-        status: z11.enum(["open", "won", "lost", "all"]).optional(),
-        q: z11.string().max(200).optional(),
+        pipeline: z13.string().uuid().optional(),
+        status: z13.enum(["open", "won", "lost", "all"]).optional(),
+        q: z13.string().max(200).optional(),
         ...page
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
@@ -3928,7 +4156,7 @@ function registerDealTools(server, client) {
       title: "Make a deal",
       description: "A new deal in the stage named (list_pipelines gives the ids). A won or lost stage closes it at once; a lost one cannot be made directly. Automations that start on a new deal run as in the app.",
       inputSchema: {
-        stageId: z11.string().uuid(),
+        stageId: z13.string().uuid(),
         ...dealFields
       }
     },
@@ -3948,10 +4176,10 @@ function registerDealTools(server, client) {
       description: "Changes only the fields sent. A new stageId moves the deal, also to another pipeline of the same deals list; moving into a lost stage needs lostReason. Deleting a deal is done in the app.",
       inputSchema: {
         id: dealId,
-        stageId: z11.string().uuid().optional(),
+        stageId: z13.string().uuid().optional(),
         ...dealFields,
         name: dealFields.name.optional(),
-        lostReason: z11.string().min(1).max(500).nullable().optional()
+        lostReason: z13.string().min(1).max(500).nullable().optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -3989,7 +4217,7 @@ function registerDealTools(server, client) {
     {
       title: "Write a note on a deal",
       description: "A note on a deal, with no author: it was written through the API.",
-      inputSchema: { dealId, body: z11.string().min(1).max(2e4) }
+      inputSchema: { dealId, body: z13.string().min(1).max(2e4) }
     },
     async ({ dealId: id7, body }) => {
       try {
@@ -4007,32 +4235,32 @@ function describeDeal(deal) {
 }
 
 // src/document-tools.ts
-import { z as z12 } from "zod";
-var id = z12.string().uuid();
-var date = z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional().describe("YYYY-MM-DD.");
-var line = z12.object({
-  name: z12.string().min(1).max(500),
-  description: z12.string().max(5e3).nullable().optional(),
-  quantity: z12.number().positive(),
-  unitPriceCents: z12.number().int().describe(
+import { z as z14 } from "zod";
+var id = z14.string().uuid();
+var date = z14.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional().describe("YYYY-MM-DD.");
+var line = z14.object({
+  name: z14.string().min(1).max(500),
+  description: z14.string().max(5e3).nullable().optional(),
+  quantity: z14.number().positive(),
+  unitPriceCents: z14.number().int().describe(
     "In cents: 12500 is 125.00. Negative for a line that takes something off."
   ),
-  taxRateId: z12.string().uuid().nullable().optional().describe("One of list_tax_rates; left out, the account\u2019s default rate."),
-  productId: z12.string().uuid().nullable().optional(),
-  lineGroup: z12.string().min(1).max(200).nullable().optional()
+  taxRateId: z14.string().uuid().nullable().optional().describe("One of list_tax_rates; left out, the account\u2019s default rate."),
+  productId: z14.string().uuid().nullable().optional(),
+  lineGroup: z14.string().min(1).max(200).nullable().optional()
 });
 var header = {
   contactRecordId: id.nullable().optional(),
   companyRecordId: id.nullable().optional(),
   dealId: id.nullable().optional(),
-  notes: z12.string().max(2e4).nullable().optional(),
-  discountType: z12.enum(["flat", "percent"]).optional(),
-  discountValue: z12.number().nonnegative().optional().describe(
+  notes: z14.string().max(2e4).nullable().optional(),
+  discountType: z14.enum(["flat", "percent"]).optional(),
+  discountValue: z14.number().nonnegative().optional().describe(
     "Cents for flat, a percentage (at most 100) for percent; sent together with discountType."
   )
 };
 var listInput = {
-  status: z12.string().max(40).optional(),
+  status: z14.string().max(40).optional(),
   contactRecordId: id.optional(),
   ...page
 };
@@ -4115,9 +4343,9 @@ function registerDocumentTools(server, client) {
       description: `A draft estimate with its lines, in EUR unless currency says otherwise. Nobody receives it. ${NOT_HERE}`,
       inputSchema: {
         ...header,
-        currency: z12.string().regex(/^[A-Z]{3}$/).optional(),
+        currency: z14.string().regex(/^[A-Z]{3}$/).optional(),
         expiryDate: date,
-        lines: z12.array(line).min(1).max(200)
+        lines: z14.array(line).min(1).max(200)
       }
     },
     async (input) => {
@@ -4138,7 +4366,7 @@ function registerDocumentTools(server, client) {
         id,
         ...header,
         expiryDate: date,
-        lines: z12.array(line).min(1).max(200).optional()
+        lines: z14.array(line).min(1).max(200).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -4158,10 +4386,10 @@ function registerDocumentTools(server, client) {
       description: `A draft invoice with its lines, in EUR unless currency says otherwise; the due date follows the account\u2019s payment terms when left out. Nobody receives it. ${NOT_HERE}`,
       inputSchema: {
         ...header,
-        currency: z12.string().regex(/^[A-Z]{3}$/).optional(),
+        currency: z14.string().regex(/^[A-Z]{3}$/).optional(),
         dueDate: date,
         deliveryDate: date,
-        lines: z12.array(line).min(1).max(200)
+        lines: z14.array(line).min(1).max(200)
       }
     },
     async (input) => {
@@ -4183,7 +4411,7 @@ function registerDocumentTools(server, client) {
         ...header,
         dueDate: date,
         deliveryDate: date,
-        lines: z12.array(line).min(1).max(200).optional()
+        lines: z14.array(line).min(1).max(200).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -4203,8 +4431,8 @@ function describeDocument(document) {
 }
 
 // src/email-template-tools.ts
-import { z as z13 } from "zod";
-var id2 = z13.string().uuid();
+import { z as z15 } from "zod";
+var id2 = z15.string().uuid();
 function registerEmailTemplateTools(server, client) {
   server.registerTool(
     "list_email_templates",
@@ -4212,7 +4440,7 @@ function registerEmailTemplateTools(server, client) {
       title: "List e-mail templates",
       description: "The account\u2019s own e-mail templates, paged by id; kind narrows to transactional (one-to-one) or marketing. The built-in system mails (sign-in, password, receipts) are not among them.",
       inputSchema: {
-        kind: z13.enum(["transactional", "marketing"]).optional(),
+        kind: z15.enum(["transactional", "marketing"]).optional(),
         ...page
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
@@ -4246,7 +4474,7 @@ function registerEmailTemplateTools(server, client) {
       }
     }
   );
-  const design = z13.record(z13.string(), z13.unknown()).describe(
+  const design = z15.record(z15.string(), z15.unknown()).describe(
     "The e-mail designer\u2019s document, in the shape get_email_template shows."
   );
   server.registerTool(
@@ -4255,14 +4483,14 @@ function registerEmailTemplateTools(server, client) {
       title: "Save a new e-mail template",
       description: "Saves a template; nobody receives anything. The app turns the design into the mail and cleans it.",
       inputSchema: {
-        name: z13.string().min(1).max(120),
-        subject: z13.string().min(1).max(300),
+        name: z15.string().min(1).max(120),
+        subject: z15.string().min(1).max(300),
         design,
-        kind: z13.enum(["transactional", "marketing"]).optional(),
-        language: z13.string().min(2).max(10).describe("nl or en."),
-        category: z13.string().min(1).max(80).nullable().optional(),
+        kind: z15.enum(["transactional", "marketing"]).optional(),
+        language: z15.string().min(2).max(10).describe("nl or en."),
+        category: z15.string().min(1).max(80).nullable().optional(),
         layoutId: id2.nullable().optional(),
-        compositionMode: z13.enum(["layout", "standalone"]).optional()
+        compositionMode: z15.enum(["layout", "standalone"]).optional()
       }
     },
     async (input) => {
@@ -4281,12 +4509,12 @@ function registerEmailTemplateTools(server, client) {
       description: "Only what is sent changes; a design sent replaces the design. Nobody receives anything.",
       inputSchema: {
         id: id2,
-        name: z13.string().min(1).max(120).optional(),
-        subject: z13.string().min(1).max(300).optional(),
+        name: z15.string().min(1).max(120).optional(),
+        subject: z15.string().min(1).max(300).optional(),
         design: design.optional(),
-        category: z13.string().min(1).max(80).nullable().optional(),
+        category: z15.string().min(1).max(80).nullable().optional(),
         layoutId: id2.nullable().optional(),
-        compositionMode: z13.enum(["layout", "standalone"]).optional()
+        compositionMode: z15.enum(["layout", "standalone"]).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -4305,8 +4533,8 @@ function describeTemplate(template) {
 }
 
 // src/event-tools.ts
-import { z as z14 } from "zod";
-var moment = z14.string().datetime({ offset: true }).optional().describe("An ISO timestamp with its offset, such as 2026-11-01T00:00:00Z.");
+import { z as z16 } from "zod";
+var moment = z16.string().datetime({ offset: true }).optional().describe("An ISO timestamp with its offset, such as 2026-11-01T00:00:00Z.");
 function registerEventTools(server, client) {
   server.registerTool(
     "list_events",
@@ -4334,7 +4562,7 @@ function registerEventTools(server, client) {
       title: "Read one event",
       description: "One event as its page needs it: description, doors and sales times, address, ticket types with their prices, and the texts for search engines. May be a minute old; ask get_event_availability for seats that must be current.",
       inputSchema: {
-        idOrSlug: z14.string().min(1).max(200).describe("The id or the address (slug) of the event.")
+        idOrSlug: z16.string().min(1).max(200).describe("The id or the address (slug) of the event.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -4359,7 +4587,7 @@ function registerEventTools(server, client) {
       title: "Seats left for an event",
       description: "Live, not cached: how many seats are left for the event and for each ticket type, and whether it is sold out. A remaining of null means there is no ceiling.",
       inputSchema: {
-        eventId: z14.string().uuid().describe("The id of the event.")
+        eventId: z16.string().uuid().describe("The id of the event.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -4387,8 +4615,8 @@ function describeEvent(event) {
 }
 
 // src/form-definition-tools.ts
-import { z as z15 } from "zod";
-var id3 = z15.string().uuid();
+import { z as z17 } from "zod";
+var id3 = z17.string().uuid();
 function registerFormDefinitionTools(server, client) {
   server.registerTool(
     "list_form_definitions",
@@ -4433,9 +4661,9 @@ function registerFormDefinitionTools(server, client) {
       title: "Make a form",
       description: "A new, empty draft form; its address follows from the name. Add fields with update_form.",
       inputSchema: {
-        name: z15.string().min(1).max(120),
-        submitLabel: z15.string().min(1).max(60).optional(),
-        successMessage: z15.string().min(1).max(500).optional()
+        name: z17.string().min(1).max(120),
+        submitLabel: z17.string().min(1).max(60).optional(),
+        successMessage: z17.string().min(1).max(500).optional()
       }
     },
     async (input) => {
@@ -4454,11 +4682,11 @@ function registerFormDefinitionTools(server, client) {
       description: "Only what is sent changes; fields sent replace every field. status published puts the form live at once on every site it is placed on, and needs an e-mail field. What happens after a submission (deals, tasks, tags, mails) is set up in the app.",
       inputSchema: {
         id: id3,
-        name: z15.string().min(1).max(120).optional(),
-        fields: z15.array(z15.unknown()).max(500).optional(),
-        settings: z15.record(z15.string(), z15.unknown()).optional(),
-        spamSettings: z15.record(z15.string(), z15.unknown()).optional(),
-        status: z15.enum(["draft", "published", "archived"]).optional()
+        name: z17.string().min(1).max(120).optional(),
+        fields: z17.array(z17.unknown()).max(500).optional(),
+        settings: z17.record(z17.string(), z17.unknown()).optional(),
+        spamSettings: z17.record(z17.string(), z17.unknown()).optional(),
+        status: z17.enum(["draft", "published", "archived"]).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -4477,7 +4705,7 @@ function describeForm(form) {
 }
 
 // src/hosting-order-page-tools.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 function registerHostingOrderPageTools(server, client) {
   server.registerTool(
     "get_hosting_order_page",
@@ -4501,19 +4729,19 @@ function registerHostingOrderPageTools(server, client) {
       title: "Set up the hosting order page",
       description: "Changes the hosting order page; only what is sent changes. `packages` is the whole list in the order the page shows it (product ids from get_hosting_order_page candidates), `allowedOrigins` the whole list of sites the snippet may stand on -- add the site before placing the snippet. `enabled: true` opens real payments. It is refused while the page cannot deliver what it sells; the refusal names what the account owner has to fix in the app themselves (a registrar login, the renewal round still in shadow mode) -- pass that on, do not retry.",
       inputSchema: {
-        enabled: z16.boolean().optional(),
-        quickTlds: z16.array(z16.string().max(30)).max(12).optional().describe("Extensions without a dot, such as nl, com, be."),
-        defaultPeriod: z16.enum(["month", "year"]).optional(),
-        packages: z16.array(
-          z16.object({
-            productId: z16.string().uuid(),
-            service: z16.enum(["hosting", "email"]),
-            featured: z16.boolean().optional(),
-            badge: z16.string().max(40).nullable().optional(),
-            highlights: z16.array(z16.string().max(80)).max(4).optional()
+        enabled: z18.boolean().optional(),
+        quickTlds: z18.array(z18.string().max(30)).max(12).optional().describe("Extensions without a dot, such as nl, com, be."),
+        defaultPeriod: z18.enum(["month", "year"]).optional(),
+        packages: z18.array(
+          z18.object({
+            productId: z18.string().uuid(),
+            service: z18.enum(["hosting", "email"]),
+            featured: z18.boolean().optional(),
+            badge: z18.string().max(40).nullable().optional(),
+            highlights: z18.array(z18.string().max(80)).max(4).optional()
           })
         ).max(24).optional(),
-        allowedOrigins: z16.array(z16.string().max(255)).max(20).optional().describe(
+        allowedOrigins: z18.array(z18.string().max(255)).max(20).optional().describe(
           "Origins such as https://example.com: no path, lower case."
         )
       },
@@ -4546,7 +4774,7 @@ function describe(page2) {
 }
 
 // src/order-tools.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 function registerOrderTools(server, client) {
   server.registerTool(
     "get_order",
@@ -4554,7 +4782,7 @@ function registerOrderTools(server, client) {
       title: "Read one order",
       description: "One order by its number, its id or its Stripe PaymentIntent (pi_\u2026): payment status, whether it was sent, the lines and the totals. Live, never cached. It does not say who bought it or where it went, and it cannot change, ship or refund an order: that is done in the app.",
       inputSchema: {
-        ref: z17.string().min(1).max(200).describe("The order number, its id, or a pi_\u2026 PaymentIntent id.")
+        ref: z19.string().min(1).max(200).describe("The order number, its id, or a pi_\u2026 PaymentIntent id.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -4570,29 +4798,59 @@ function registerOrderTools(server, client) {
       }
     }
   );
+  server.registerTool(
+    "list_orders",
+    {
+      title: "List orders",
+      description: "The account\u2019s orders paged by id, in the shape get_order reads one. sellerRef narrows them to orders paid through a payment link that carried ?ref=<sellerRef> -- how whoever sent the link learns it was paid, and which customer account the order made (clientAccountId). Never who bought it.",
+      inputSchema: {
+        sellerRef: z19.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional().describe("The ?ref= the payment link carried."),
+        ...page
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const result = await client.getOrders(input);
+        return answer(
+          result.data.length === 0 ? input.sellerRef ? `No order carries the mark "${input.sellerRef}".` : "No orders." : [
+            ...result.data.map((order) => describeOrder(order)),
+            more(result.nextCursor)
+          ].filter(Boolean).join("\n\n"),
+          result
+        );
+      } catch (error) {
+        return refusal(error, "orders:read");
+      }
+    }
+  );
 }
 function describeOrder(order) {
   const test = order.livemode ? "" : " (test)";
   const lines = order.lines.map(
     (line2) => `- ${line2.quantity} \xD7 ${line2.name}: ${money(line2.totalCents, order.currency)}`
   );
+  const made = order.clientAccountId ? `Customer account: ${order.clientAccountId}.` : "";
+  const mark = order.sellerRef ? `Mark: ${order.sellerRef}.` : "";
   return [
     `Order ${order.number}${test}: ${order.status}, ${order.fulfilmentStatus}, ${money(order.totalCents, order.currency)}.`,
-    ...lines
-  ].join("\n");
+    ...lines,
+    mark,
+    made
+  ].filter(Boolean).join("\n");
 }
 
 // src/payment-page-tools.ts
-import { z as z18 } from "zod";
-var id4 = z18.string().uuid();
-var slug = z18.string().min(2).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe("Lowercase letters, digits and hyphens.");
+import { z as z20 } from "zod";
+var id4 = z20.string().uuid();
+var slug2 = z20.string().min(2).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe("Lowercase letters, digits and hyphens.");
 function registerPaymentPageTools(server, client) {
   server.registerTool(
     "list_payment_pages",
     {
       title: "List payment pages",
       description: "The account\u2019s payment pages, paged by id; archived ones only with archived: true.",
-      inputSchema: { archived: z18.boolean().optional(), ...page },
+      inputSchema: { archived: z20.boolean().optional(), ...page },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
     async (input) => {
@@ -4635,8 +4893,8 @@ ${blockers}`, page2);
       title: "Make a payment page",
       description: "A draft payment page for one of the account\u2019s products. Nothing is live until a person publishes it in the app. Without priceId the buyer picks from the product\u2019s active price options.",
       inputSchema: {
-        name: z18.string().min(1).max(120),
-        slug: slug.optional(),
+        name: z20.string().min(1).max(120),
+        slug: slug2.optional(),
         productId: id4,
         priceId: id4.optional()
       }
@@ -4657,13 +4915,13 @@ ${blockers}`, page2);
       description: "Only what is sent changes. content takes whole blocks: hero {headline, subheadline}, bullets {title, items}, quote {text, author, role}, guarantee {title, body}, faq {items: [{question, answer}]}, trust {items}, paymentOptions {recommendedPriceId, note}; a block left out stays. settings takes termsUrl, requireFields, excludedPaymentMethods (what is switched OFF), thankYouMode, redirectUrl, createInvoice, maxQuantity, customFields, tagOnPurchase. status goes back to draft (off the web) or archived; publishing is done in the app. A new slug breaks links already sent.",
       inputSchema: {
         id: id4,
-        name: z18.string().min(1).max(120).optional(),
-        slug: slug.optional(),
+        name: z20.string().min(1).max(120).optional(),
+        slug: slug2.optional(),
         productId: id4.optional(),
         priceId: id4.nullable().optional(),
-        status: z18.enum(["draft", "archived"]).optional(),
-        content: z18.record(z18.string(), z18.unknown()).optional(),
-        settings: z18.record(z18.string(), z18.unknown()).optional()
+        status: z20.enum(["draft", "archived"]).optional(),
+        content: z20.record(z20.string(), z20.unknown()).optional(),
+        settings: z20.record(z20.string(), z20.unknown()).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -4682,9 +4940,9 @@ function describePage(page2) {
 }
 
 // src/placement-tools.ts
-import { z as z19 } from "zod";
+import { z as z21 } 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 origin = z19.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 = z21.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",
@@ -4757,13 +5015,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: z19.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
+        slug: z21.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
           'The widget\u2019s address on this account, such as "website-chat".'
         ),
-        name: z19.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
-        status: z19.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
-        addAllowedOrigins: z19.array(origin).max(20).optional(),
-        removeAllowedOrigins: z19.array(origin).max(20).optional()
+        name: z21.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
+        status: z21.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
+        addAllowedOrigins: z21.array(origin).max(20).optional(),
+        removeAllowedOrigins: z21.array(origin).max(20).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -4771,9 +5029,9 @@ function registerPlacementTools(server, client) {
         idempotentHint: true
       }
     },
-    async ({ slug: slug2, ...input }) => {
+    async ({ slug: slug3, ...input }) => {
       try {
-        const widget = await client.upsertChatWidget(slug2, input);
+        const widget = await client.upsertChatWidget(slug3, input);
         return answer(
           `${widget.created ? "Made" : "Updated"} the widget.
 
@@ -4811,9 +5069,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: z19.array(z19.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
-        removeAllowedHosts: z19.array(z19.string()).max(20).optional(),
-        consentSignal: z19.enum([
+        addAllowedHosts: z21.array(z21.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
+        removeAllowedHosts: z21.array(z21.string()).max(20).optional(),
+        consentSignal: z21.enum([
           "ad_storage",
           "analytics_storage",
           "personalization_storage",
@@ -4874,14 +5132,14 @@ function describeSiteTracking(site) {
 }
 
 // src/record-tools.ts
-import { z as z20 } from "zod";
-var recordId = z20.string().uuid().describe("The id of the record.");
-var values = z20.record(z20.string(), z20.unknown()).describe(
+import { z as z22 } from "zod";
+var recordId = z22.string().uuid().describe("The id of the record.");
+var values = z22.record(z22.string(), z22.unknown()).describe(
   "Field values by field slug, as list_record_lists names them. A field marked sensitive is refused."
 );
-var tags = z20.object({
-  add: z20.array(z20.string().uuid()).max(50).optional(),
-  remove: z20.array(z20.string().uuid()).max(50).optional()
+var tags = z22.object({
+  add: z22.array(z22.string().uuid()).max(50).optional(),
+  remove: z22.array(z22.string().uuid()).max(50).optional()
 }).optional().describe("Tag ids to put on or take off; list_tags names them.");
 function registerRecordTools(server, client) {
   server.registerTool(
@@ -4906,8 +5164,8 @@ function registerRecordTools(server, client) {
       title: "Search the records of one list",
       description: "The records of one list, by its slug, paged. q searches the name and every value but a sensitive one. Records whose processing is restricted are left out.",
       inputSchema: {
-        list: z20.string().min(1).max(64).describe("The slug of the list."),
-        q: z20.string().max(200).optional(),
+        list: z22.string().min(1).max(64).describe("The slug of the list."),
+        q: z22.string().max(200).optional(),
         ...page
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
@@ -4947,7 +5205,7 @@ function registerRecordTools(server, client) {
       title: "Make a record",
       description: "A new record in a list (left out: a person, where the account puts new contacts). A person whose e-mail or phone is already known is not made again: the answer gives only their id (matched), nothing on them changes, and get_record reads them; use update_record to change them. Automations that start on a new record run as they do for one made in the app.",
       inputSchema: {
-        list: z20.string().min(1).max(64).optional(),
+        list: z22.string().min(1).max(64).optional(),
         values,
         tags
       }
@@ -4973,7 +5231,7 @@ function registerRecordTools(server, client) {
         id: recordId,
         values: values.optional(),
         tags,
-        ownerId: z20.string().uuid().nullable().optional()
+        ownerId: z22.string().uuid().nullable().optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -5037,7 +5295,7 @@ function registerRecordTools(server, client) {
       description: "A note on a record\u2019s timeline, shown as written through the API with the name of this key.",
       inputSchema: {
         recordId,
-        body: z20.string().min(1).max(2e4)
+        body: z22.string().min(1).max(2e4)
       }
     },
     async ({ recordId: id7, body }) => {
@@ -5055,12 +5313,12 @@ function registerRecordTools(server, client) {
       title: "Add a contact, or find the one already known",
       description: "A person by e-mail address. Somebody already known by that address is matched rather than made twice (created: false), and the answer is their id. A field left out is never cleared on a contact already known.",
       inputSchema: {
-        email: z20.string().email().max(320),
-        firstName: z20.string().trim().min(1).max(200).optional(),
-        lastName: z20.string().trim().min(1).max(200).optional(),
-        phone: z20.string().trim().min(1).max(50).optional(),
-        company: z20.string().trim().min(1).max(200).optional(),
-        object: z20.string().trim().min(1).max(64).optional().describe(
+        email: z22.string().email().max(320),
+        firstName: z22.string().trim().min(1).max(200).optional(),
+        lastName: z22.string().trim().min(1).max(200).optional(),
+        phone: z22.string().trim().min(1).max(50).optional(),
+        company: z22.string().trim().min(1).max(200).optional(),
+        object: z22.string().trim().min(1).max(64).optional().describe(
           "The slug of the list for people a new contact goes into; left out, the account\u2019s own choice."
         )
       },
@@ -5142,20 +5400,20 @@ function registerServerInfoTool(server, info) {
 }
 
 // src/shop-setup-tools.ts
-import { z as z21 } from "zod";
-var id5 = z21.string().uuid();
-var cents2 = z21.number().int().min(0).max(99999999);
-var region = z21.object({
-  countryCode: z21.string().regex(/^[A-Z]{2}$/).describe("Two capital letters, ISO 3166 (NL, BE, DE)."),
-  postcodeFrom: z21.string().max(20).nullable().default(null).describe("With postcodeTo: only this range of the country."),
-  postcodeTo: z21.string().max(20).nullable().default(null)
+import { z as z23 } from "zod";
+var id5 = z23.string().uuid();
+var cents2 = z23.number().int().min(0).max(99999999);
+var region = z23.object({
+  countryCode: z23.string().regex(/^[A-Z]{2}$/).describe("Two capital letters, ISO 3166 (NL, BE, DE)."),
+  postcodeFrom: z23.string().max(20).nullable().default(null).describe("With postcodeTo: only this range of the country."),
+  postcodeTo: z23.string().max(20).nullable().default(null)
 });
-var discount = z21.object({
-  name: z21.string().min(1).max(120).describe("What the team sees it as."),
-  code: z21.string().max(40).nullable().describe(
+var discount = z23.object({
+  name: z23.string().min(1).max(120).describe("What the team sees it as."),
+  code: z23.string().max(40).nullable().describe(
     "What a buyer types (upper-cased), or null for one that applies on its own."
   ),
-  effect: z21.enum([
+  effect: z23.enum([
     "tier_price",
     "percent_off_lines",
     "amount_off_lines",
@@ -5165,19 +5423,19 @@ var discount = z21.object({
   ]).describe(
     "tier_price: a lower price from tierMinQuantity of one product; *_lines: off each matching line; *_order: once off the whole order; free_shipping: no postage."
   ),
-  percent: z21.number().nullable().describe("For a percentage: above 0, at most 100."),
-  amountCents: z21.number().int().nullable().describe("For an amount, in currency, as the account enters prices."),
-  currency: z21.string().regex(/^[A-Z]{3}$/).nullable().describe("Required beside amountCents (EUR)."),
-  tierMinQuantity: z21.number().int().nullable(),
-  minSubtotalCents: z21.number().int().nullable().describe("Only from this basket value, before discount."),
-  productIds: z21.array(id5).max(500).describe("Empty: every product."),
-  categoryIds: z21.array(id5).max(100),
-  objectIds: z21.array(id5).max(20),
-  startsAt: z21.string().datetime({ offset: true }).nullable(),
-  endsAt: z21.string().datetime({ offset: true }).nullable(),
-  maxUses: z21.number().int().positive().nullable(),
-  maxUsesPerEmail: z21.number().int().positive().nullable(),
-  combinable: z21.boolean().describe(
+  percent: z23.number().nullable().describe("For a percentage: above 0, at most 100."),
+  amountCents: z23.number().int().nullable().describe("For an amount, in currency, as the account enters prices."),
+  currency: z23.string().regex(/^[A-Z]{3}$/).nullable().describe("Required beside amountCents (EUR)."),
+  tierMinQuantity: z23.number().int().nullable(),
+  minSubtotalCents: z23.number().int().nullable().describe("Only from this basket value, before discount."),
+  productIds: z23.array(id5).max(500).describe("Empty: every product."),
+  categoryIds: z23.array(id5).max(100),
+  objectIds: z23.array(id5).max(20),
+  startsAt: z23.string().datetime({ offset: true }).nullable(),
+  endsAt: z23.string().datetime({ offset: true }).nullable(),
+  maxUses: z23.number().int().positive().nullable(),
+  maxUsesPerEmail: z23.number().int().positive().nullable(),
+  combinable: z23.boolean().describe(
     "Whether it may count beside another discount on the same order."
   )
 });
@@ -5230,8 +5488,8 @@ function registerShopSetupTools(server, client) {
       description: "A zone is a name and the countries (or postcode ranges) it covers. Without id a new zone; with one, that zone renamed and its places replaced by these. Answers the zone id, for upsert_shipping_method.",
       inputSchema: {
         id: id5.optional().describe("The zone to change; leave out for a new one."),
-        name: z21.string().min(1).max(80),
-        regions: z21.array(region).max(300).default([])
+        name: z23.string().min(1).max(80),
+        regions: z23.array(region).max(300).default([])
       },
       annotations: { idempotentHint: true }
     },
@@ -5255,14 +5513,14 @@ function registerShopSetupTools(server, client) {
       inputSchema: {
         id: id5.optional(),
         zoneId: id5,
-        kind: z21.enum(["flat_rate", "free_shipping", "local_pickup"]),
-        name: z21.string().min(1).max(80).describe("What the buyer chooses."),
-        enabled: z21.boolean().default(true),
+        kind: z23.enum(["flat_rate", "free_shipping", "local_pickup"]),
+        name: z23.string().min(1).max(80).describe("What the buyer chooses."),
+        enabled: z23.boolean().default(true),
         amountCents: cents2.default(0),
         noClassAmountCents: cents2.default(0),
         taxRateId: id5.nullish(),
         freeThresholdCents: cents2.nullish(),
-        classRates: z21.array(z21.object({ classId: id5, amountCents: cents2 })).max(100).default([])
+        classRates: z23.array(z23.object({ classId: id5, amountCents: cents2 })).max(100).default([])
       },
       annotations: { idempotentHint: true }
     },
@@ -5283,7 +5541,7 @@ function registerShopSetupTools(server, client) {
     {
       title: "List discounts",
       description: "The account discounts, newest first, at most 200: codes, the ones that apply on their own, and tier prices, with every condition and how many paid orders used each. Archived ones only with archived: true.",
-      inputSchema: { archived: z21.boolean().optional() },
+      inputSchema: { archived: z23.boolean().optional() },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
     async ({ archived }) => {
@@ -5325,7 +5583,7 @@ function registerShopSetupTools(server, client) {
       description: "Stops a discount from giving anything to a new cart or order; orders that used it keep it. archived: false brings it back. Deleting is left to a person in the app.",
       inputSchema: {
         id: id5,
-        archived: z21.boolean().default(true)
+        archived: z23.boolean().default(true)
       },
       annotations: { idempotentHint: true }
     },
@@ -5390,9 +5648,9 @@ function registerShopSetupTools(server, client) {
       description: "Point the account at the site revalidation route (with the SDK: https://<site>/api/solumflow/revalidate) so its cached pages follow a product the moment it changes. Without id a new address: the answer carries its signing key once -- put it in the site environment as SOLUMFLOW_WEBHOOK_KEY, it cannot be read back. https only, never a private network.",
       inputSchema: {
         id: id5.optional(),
-        name: z21.string().min(1).max(80),
-        url: z21.string().url().max(2048),
-        events: z21.array(z21.string().min(1).max(60)).min(1).max(20).describe(
+        name: z23.string().min(1).max(80),
+        url: z23.string().url().max(2048),
+        events: z23.array(z23.string().min(1).max(60)).min(1).max(20).describe(
           "For a shop: product.changed, product.deleted, category.changed."
         )
       },
@@ -5428,7 +5686,7 @@ function describeDiscount(entry) {
 }
 
 // src/shop-test-order-tool.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 var PAID_POLLS = 10;
 var PAID_POLL_MS = 1500;
 function registerShopTestOrderTool(server, client, options = {}) {
@@ -5439,25 +5697,25 @@ function registerShopTestOrderTool(server, client, options = {}) {
       title: "Place and pay a test order",
       description: "Proves the shop end to end in Stripe test mode: puts one product in a cart, chooses postage, places the order, pays it with Stripe test card 4242, and reads the order back until it is paid (the invoice and the confirmation mail follow from there). Refused when the account is live -- no real money can move through this tool. Needs a key with shop:manage, cart:write, orders:write and orders:read. Pass `extras` (products from the product\u2019s own `extras` list) and `options` (by option key: a text, true, or a choice key) to prove a product with an extra or a surcharge option; the cart must show them, priced by the server, before the order is placed. Never send an amount.",
       inputSchema: {
-        email: z22.string().email().describe(
+        email: z24.string().email().describe(
           "Where the confirmation goes: the shop owner, never a customer."
         ),
-        productId: z22.string().uuid().optional().describe(
+        productId: z24.string().uuid().optional().describe(
           "The product to buy; leave out for the first one in stock."
         ),
-        countryCode: z22.string().regex(/^[A-Z]{2}$/).default("NL").describe("Where it is posted, for a product that is posted."),
-        postalCode: z22.string().max(20).optional(),
-        extras: z22.array(
-          z22.object({
-            productId: z22.string().uuid(),
-            quantity: z22.number().int().min(1).max(99).default(1)
+        countryCode: z24.string().regex(/^[A-Z]{2}$/).default("NL").describe("Where it is posted, for a product that is posted."),
+        postalCode: z24.string().max(20).optional(),
+        extras: z24.array(
+          z24.object({
+            productId: z24.string().uuid(),
+            quantity: z24.number().int().min(1).max(99).default(1)
           })
         ).max(10).optional().describe(
           "Extras to take with the product, each a product from its `extras`; for one that follows its line the quantity is per piece."
         ),
-        options: z22.record(
-          z22.string().regex(/^[a-z0-9_]{1,40}$/),
-          z22.union([z22.string().max(2e3), z22.boolean()])
+        options: z24.record(
+          z24.string().regex(/^[a-z0-9_]{1,40}$/),
+          z24.union([z24.string().max(2e3), z24.boolean()])
         ).optional().describe(
           "The choices for the product\u2019s options, by option key: a text, true for a ticked box, or the key of a choice."
         )
@@ -5584,9 +5842,9 @@ function registerShopTestOrderTool(server, client, options = {}) {
 }
 
 // src/task-tools.ts
-import { z as z23 } from "zod";
-var id6 = z23.string().uuid();
-var moment2 = z23.string().datetime({ offset: true }).describe(
+import { z as z25 } from "zod";
+var id6 = z25.string().uuid();
+var moment2 = z25.string().datetime({ offset: true }).describe(
   "An ISO moment with its offset, such as 2026-11-01T09:00:00+01:00."
 );
 var OUTSIDE_PROJECTS = "Only tasks outside projects: a project\u2019s tasks are seen differently per member and are worked on in the app.";
@@ -5597,7 +5855,7 @@ function registerTaskTools(server, client) {
       title: "List tasks",
       description: `Tasks paged by id: open and in progress unless status says otherwise; recordId, dealId and assigneeId narrow them. ${OUTSIDE_PROJECTS}`,
       inputSchema: {
-        status: z23.enum(["open", "in_progress", "done", "all"]).optional(),
+        status: z25.enum(["open", "in_progress", "done", "all"]).optional(),
         recordId: id6.optional(),
         dealId: id6.optional(),
         assigneeId: id6.optional(),
@@ -5643,14 +5901,14 @@ function registerTaskTools(server, client) {
       title: "Make a task",
       description: `A task on a contact (recordId), on a deal (dealId; with recordId one of that contact\u2019s deals), or on nothing, optionally due, prioritised and assigned to members. ${OUTSIDE_PROJECTS}`,
       inputSchema: {
-        title: z23.string().min(1).max(500),
-        description: z23.string().max(2e4).nullable().optional(),
+        title: z25.string().min(1).max(500),
+        description: z25.string().max(2e4).nullable().optional(),
         dueAt: moment2.nullable().optional(),
-        priority: z23.enum(["low", "normal", "high"]).optional(),
+        priority: z25.enum(["low", "normal", "high"]).optional(),
         recordId: id6.nullable().optional(),
         dealId: id6.nullable().optional(),
         parentTaskId: id6.nullable().optional(),
-        assigneeIds: z23.array(id6).max(20).optional()
+        assigneeIds: z25.array(id6).max(20).optional()
       }
     },
     async (input) => {
@@ -5669,12 +5927,12 @@ function registerTaskTools(server, client) {
       description: `Changes only what is sent; status done completes it. assigneeIds replaces who works on it. ${OUTSIDE_PROJECTS}`,
       inputSchema: {
         id: id6,
-        title: z23.string().min(1).max(500).optional(),
-        description: z23.string().max(2e4).nullable().optional(),
+        title: z25.string().min(1).max(500).optional(),
+        description: z25.string().max(2e4).nullable().optional(),
         dueAt: moment2.nullable().optional(),
-        priority: z23.enum(["low", "normal", "high"]).optional(),
-        status: z23.enum(["open", "in_progress", "done"]).optional(),
-        assigneeIds: z23.array(id6).max(20).optional()
+        priority: z25.enum(["low", "normal", "high"]).optional(),
+        status: z25.enum(["open", "in_progress", "done"]).optional(),
+        assigneeIds: z25.array(id6).max(20).optional()
       },
       annotations: { idempotentHint: true }
     },
@@ -5695,7 +5953,7 @@ function registerTaskTools(server, client) {
       inputSchema: {
         from: moment2,
         to: moment2,
-        kind: z23.enum(["appointment", "block", "all"]).optional(),
+        kind: z25.enum(["appointment", "block", "all"]).optional(),
         contactRecordId: id6.optional(),
         ...page
       },
@@ -5744,14 +6002,14 @@ function describeAppointment(appointment) {
 }
 
 // src/tool-definitions-version.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 import { createHash } from "crypto";
 function toolDefinitionsHash(tools) {
   const definitions = [...tools].sort((left, right) => left.name.localeCompare(right.name)).map(({ name, config }) => ({
     name,
     title: config.title ?? null,
     description: config.description ?? null,
-    inputSchema: config.inputSchema ? z24.toJSONSchema(z24.object(config.inputSchema), {
+    inputSchema: config.inputSchema ? z26.toJSONSchema(z26.object(config.inputSchema), {
       io: "input",
       unrepresentable: "any"
     }) : null,
@@ -5799,7 +6057,7 @@ function holdToolRegistrations(real) {
           description: `${config.description ?? ""} Definitions version ${version2}: send it as schemaHash and the answer tells you when these tool definitions are older than the server.`,
           inputSchema: {
             ...config.inputSchema,
-            schemaHash: z24.string().max(64).optional().describe(
+            schemaHash: z26.string().max(64).optional().describe(
               `The definitions version named in this tool's description (${version2}).`
             )
           }
@@ -5872,6 +6130,8 @@ async function main() {
   registerConsentBannerTools(held.server, client);
   registerHostingOrderPageTools(held.server, client);
   registerTaskTools(held.server, client);
+  registerClientAccountTools(held.server, client);
+  registerCalendarSetupTools(held.server, client);
   held.publish();
   await server.connect(new StdioServerTransport());
   try {